Chapitre 3 : JAVA (Suite)
Hassan El Bahi
[Link]
Plan
Qu’est ce que Poo ?
Caractéristiques d’une classe
L'héritage
Surcharge
Classe abstraite
Notion d’interface
Hassan El Bahi
[Link]
2
Programmation orientée objet
La programmation orientée objet permet de concevoir une
application sous la forme d'un ensemble d'objets reliés entre eux
par des relations.
Il consiste en la définition et l'interaction de briques logicielles
appelées objets.
un objet représente un concept, une idée ou toute entité du monde
physique, comme une voiture, une personne ou encore une page
d'un livre
3
Programme/application Java
Une application Java est composée d’une ou plusieurs classes.
Le plus souvent il est composé de plusieurs classes.
Une des classes est la classe principale dont la méthode main est
lancée pour lancer l’application.
Au début de l’exécution, seule la classe principale est chargée en
mémoire centrale.
Les autres classes sont chargées au fur et à mesure, lorsque le
programme a besoin d’elles.
Le plus souvent une classe est chargée lorsqu’une instance de la
classe est créée par le programme.
4
Représentation graphique d’un objet en UML
Exemple un objet Voiture nommé c5.
c5:Voiture
couleur=bleu
Etat
puissance=130
carburant=30
démarrer()
accélérer() Comportement
freiner()
Les objets ayant les mêmes caractéristiques sont regroupés dans
une structure formelle, appelées classe
5
Qu’est ce qu’un objet?
Un objet est une structure informatique caractérisée par un état et
un ensemble d'opérations exécutables par cet objet qui caractérise
son comportement.
Objet = état + comportement (opérations)
Exemples:
Une Fenêtre:
- Etat : position, taille, bordure, titre, couleur,...
- Opérations: dessiner, déplacer, agrandir...
Un Fichier:
- Etat : nom, directory, id, protections, propriétaire, contenu,.
- Opérations : ouvrir, fermer, détruire,
6
Classe
La classe décrit le domaine de définition d’objets.
Chaque objet appartient à une classe.
Les généralités sont contenues dans la classe alors que les
particularités dans les objets.
Les objets informatiques sont construits à partir de la classe par un
processus appelé instanciation.
De ce fait tout objet est une instance de classe.
7
Caractéristiques d’une classe
Une classe est définie par les attributs et les opérations (méthodes).
8
Caractéristiques d’une classe
Attributs:
o Appelés également champs, ou données membres, correspondent
aux propriétés de la classe.
o Ils sont définis par un nom, un type de données et éventuellement
une valeur initiale.
o Un attribut est une variable qui stocke des données.
Employé
code = int
nom = String
nbEmployés = static int
Trois attributs de la classe Employé
9
Caractéristiques d’une classe
Attributs:
o Exemple :la classe Employé caractérisée par les attributs code, nom
et nbEmployés (nombre d’employés).
o Les attributs code et nom sont des caractéristiques de chaque objet
Employé contrairement au champ nbEmployés qui est une
caractéristique commune à tous les objets. On dira que nbEmployés
est attribut statique..
o Chaque objet, instance d’une classe, donne des valeurs particulières
à tous les attributs définis dans sa classe sauf les attributs statiques
ce qui détermine son état.
10
Déclaration et initialisation de variables
Deux objets de la classe Employé :
e1 : Employé E2 : Employé
code = 1 code = 1
nom = "jamil" nom = "Ali"
Définition :
Un attribut statique d’une classe est un attribut qui appartient à la
classe et qui est partagé par tous les objets de cette classe. Un
attribut statique est considéré comme étant une variable globale à
tous les objets. Les attributs statiques ne sont pas instanciés dans
les objets.
11
Caractéristiques d’une classe
Méthodes :
o Les méthodes permettent de décrire les comportements des objets.
o Elles représentent des procédures ou des fonctions qui permettent
d’exécuter un certain nombre d’instructions.
o Parmi les méthodes d’une classe existe une méthode particulière,
qui porte le même nom que la classe, qui s’appelle le constructeur
o Le rôle du constructeur étant créer les objets de la classe en les
initialisant.
12
Caractéristiques d’une classe
Méthodes :
o Dans l’exemple précédent, nous pourrons définir les
méthodesafficheCode() et afficheNom() qui affichent respectivement
le code et le nom d’un employé.
Employé
Attributs :
code = int
nom = String Représentation graphique
nbEmployés = static int de la classe Employé En UML
Constructeur :
Employé()
Méthodes :
afficheCode() : void
afficheNom() : void 13
Exemple : la classe Employé avec java
class Employe{
// Les attributs
int code;
String nom;
static int nbEmployes = 0;
//Constructeur
Employe(){
++nbEmployes;// incrémenter le nombre d’employés
code=nbEmployes;// affecter nbEmployes au code
}
// Les méthodes
void afficheCode(){
[Link]("Le code est: " + code);
}
void afficheNom(){
[Link]("Le nom est: " + nom);
}
}
14
Création d’un objet à partir d’une classe
Pour créer un objet (ou instance ) à partir d’une classe, on utilise la
commande new suivie du nom du constructeur de la classe
Exemple : new Employé();
En java les objets sont identifiés par un handle (poignée).
Pour créer un handle, on écrit le nom de la classe suivi du nom du
handle.
Exemple : Employe e1;
e1 est une variable qui est destinée à pointer sur une instance de
la classe Employe. Pour l’instant, elle ne pointe sur aucun objet.
(e1=null)
15
Création d’un objet à partir d’une classe
Pour affecter un objet au handle e1, on utilise les deux instruction
suivantes :
Employe e1;
e1 = new Employe();
ou encore en une seule instruction:
Employe e1 = new Employe();
Handle : e1 Objet :
Adresse de l’objet Employé
code = 1
nom = "jamil"
afficheCode()
afficheNom()
16
Accéder aux membres d’un objet
Pour accéder aux membres d’un objet créé,on utilise son handle
suivi d’un point, puis du nom de l’attribut ou de la méthode.
Exemple :
o [Link]= "jamil ";
o [Link]();
o [Link]([Link]);
o [Link]([Link]);
o [Link]([Link]);
Les membre statiques sont accessibles en utilisant soit le handle
d’un objet quelconque de la classe, soit directement le nom de la
classe.
17
Exemple : Test
class TestEmploye{
public static void main(String[] args){
new Employe();
Employe e2 ;
e2=new Employe();
Employe e3=new Employe();
[Link]="Jamil";
[Link]();
[Link]();
[Link]();
[Link]("Nombre d'employés en utilisant
l'objet e2="+[Link]);
[Link]("Nombre d'employés en utilisant
l'objet e3="+[Link]);
[Link]("Nombre d'employés en utilisant
la classe Employe="+[Link]);
}
}
18
Exemple : Test
Employe e2;
new Employe(); Employe e3=new Employe();
e2=new Employe();
:Employé e2:Employé e3:Employé
Attributs : Attributs : Attributs :
code = 1 code = 2 code = 3
nom = Null nom = Jamil nom = Null
afficheCode() : void afficheCode() : void afficheCode() : void
afficheNom() : void afficheNom() : void afficheNom() : void
Premier Objet Deuxième Objet Troisième Objet
19
Exemple : Classe Ville
Ville
Attributs :
nomVille= String
nomPays= String
nbreHabitants= int
Constructeur :
Ville()
Ville (String pNom, String pPays, int pNbre)
Méthodes :
getNom() : String
getNomPays() : String
getNombreHabitants() : int
setNom() : void
setNomPays() : void
setNombreHabitants() : void
20
Constructeur par défaut
Un constructeur par défaut est un constructeur qui peut être appelé
sans paramètre. A noter qu'il peut s'agir d'un constructeur sans
paramètres, ou d'un constructeur dont les paramètres ont des
valeurs par défaut.
public class Ville{
String nomVille;
String nomPays;
int nbreHabitants;
//Constructeur par défaut
public Ville(){
[Link]("Création d'une ville !");
nomVille = "Inconnu";
nomPays = "Inconnu";
nbreHabitants = 0;
}
}
21
Constructeur avec paramètres
public class Ville {
String nomVille;
String nomPays;
int nbreHabitants;
//Constructeur par défaut
public Ville(){
[Link]("Création d'une ville !");
nomVille = "Inconnu";
nomPays = "Inconnu";
nbreHabitants = 0;
}
//Constructeur avec paramètres
public Ville(String pNom, String pPays, int pNbre) {
[Link]("Création d'une ville avec des paramètres!");
nomVille = pNom;
nomPays = pPays;
nbreHabitants = pNbre;
}
}
22
Accesseurs et mutateurs
Un accesseur est une méthode qui permet d'obtenir la valeur d'un
attribut . Un mutateur est une méthode qui permet de définir ou
modifier la valeur d'un attribut .
public class Ville {
//Les variables et les constructeurs n'ont pas changé…
//************* ACCESSEURS *************
//Retourne le nom de la ville
public String getNom() { return nomVille; }
//Retourne le nom du pays
public String getNomPays() { return nomPays; }
// Retourne le nombre d'habitants
public int getNombreHabitants() { return nbreHabitants; }
//************* MUTATEURS ************* //
Définit le nom de la ville
public void setNom(String pNom) { nomVille = pNom; }
//Définit le nom du pays
public void setNomPays(String pPays) { nomPays = pPays; }
//Définit le nombre d'habitants
public void setNombreHabitants(int nbre) { nbreHabitants = nbre; }
}
La notion d'héritage
L'héritage est un mécanisme permettant de créer une nouvelle
classe à partir d'une classe existante en lui proférant ses
propriétés et ses méthodes.
Ainsi, pour définir une nouvelle classe, il suffit de la faire hériter
d'une classe existante et de lui ajouter de nouvelles
propriétés/méthodes
Considérons le modèle suivant :
Object
Animal
Chien Chat Canari
Teckel Labrador Caniche
24
Concepts de l’héritage
La classe Animal peut s’écrire :
class Animal {
boolean vivant; Animal
int âge; Attributs :
Animal (int a) {
vivant = boolean
age = a;
vivant = true;
âge = int
} Constructeur :
void vieillit() { Animal(int a)
++age; Méthodes:
} crie() : void
void meurt() {
vieillit() : void
vivant = false;
}
meurt() : void
void crie() { }
}
Dans ce cas, la création d'un Animal se ferait à l'aide de l'instruction suivante :
Animal nouvelAnimal = new Animal(3);
25
La notion d'héritage
Référence à la classe parente :
Pour éviter de réécrire le même code du constructeur de la classe
Animal, on fera référence à la classe parente en utilisant le mot
super
La classe Canari devient :
class Canari extends Animal{
Canari(int a){
super(a);
}
}
26
Surcharge
Surcharger une méthode:
La classe Animal possède une méthode vieillit() sans paramètre et
qui incrémente l’âge d’une unité.
Nous pouvons ajouter à la classe Animal une autre méthode qui
porte le même nom mais qui possède un paramètre a qui indique
le nombre d’années à ajouter pendant lanniversaire de l’animal.
Voici le code des deux méthodes:
void vieillit(){
++âge;
[Link]("C'est l'anniversaire de cet animal.");
[Link]("Il a maintenant"+age+"an(s).");
}
void vieillit(int a){
âge+=a;
[Link]("C'est l'anniversaire de cet animal.");
[Link]("Il a maintenant"+age+"an(s).");
}
27
Surcharge
Pour éviter de réécrire les mêmes instructions dans les deux
méthodes, on peut constater que la méthode vieillit() est un cas
particulier de la méthode vieillit(int a). Les deux méthodes
s’écriront alors:
void vieillit(){
vieillit(1)
}
void vieillit(int a){
âge+=a;
[Link]("C'est l'anniversaire de cet animal.");
[Link]("Il a maintenant"+age+"an(s).");
}
L’appel des deux méthodes peut se faire comme suit :
Canaria1=new Canari(3);
[Link]();
[Link](6);
28
Surcharge
Signature d’une méthode :
La signature d'une méthode désigne la liste de ses paramètres avec
leur type.
Les deux méthode vieillit(int a) et vieillit() ont le même nom et deux
signatures différentes.
Les deux méthodes suivantes :
o méthode(int a,long b)
o méthode(long b,int a)
o ont deux signatures différentes.
Alors que les méthodes :
o méthode(int a, long b)
o méthode(int c, long d)
o ont même signature.
29
Surcharge
Surcharger le Constructeur :
On peut également constater que le premier constructeur est un cas
particulier du deuxième.
Un constructeur peut appeler un autre en utilisant le mot this qui désigne
l’objet courant.
Animal() {
this(1);
}
Animal(int a) {
âge = a;
vivant = true;
[Link]("Un animal de " + a + " an(s) vient
d'être créé");
}
On pourra créer une instance de la classe Animal en utilisant l’un des
deux constructeurs:
Animal A1=new Animal();
Animal A2= new Animal(4);
30
class Canari extends Animal {
Programme Test Canari(int a) {
super(a);
class Animal { }
boolean vivant; Canari() {
int âge;
this(1);
int âgeMaxi = 10;
Animal(int a) { }
âge = a; void crie() {
vivant = true; [Link]("Cui-
[Link]("Un animal de " + a + cui !");
" an(s) vient d'être créé");} }
Animal() { }
this(1); }
void vieillit(int a) {
âge += a; class TestAnimaux {
if (âge > âgeMaxi) meurt(); public static void
else{
main(String[] args) {
[Link]("C'est l'anniversaire
de cet animal."); [Link]("Il a Canari titi = new Canari(3);
maintenant " + âge + " an(s)"); } } Canari mimi=new Canari();
void vieillit() { [Link]=5;
vieillit(1); } [Link]();
void meurt() { [Link]();
vivant = false; [Link](4);
[Link]("Cet animal est mort");
[Link](5);
}
void crie() { } [Link](); }
} }
31
Résumé héritage
Pour qu’une classe hérite d’une autre, on utilise le mot extends.
Une classe peut hériter d’une autre tout sauf les constructeurs.
Il faut toujours définir le constructeur de la nouvelle classe dérivée.
Le constructeur de la nouvelle classe dérivée peut faire appel au
constructeur de la classe parente en utilisant le mot super suivi des valeurs
des arguments entre parenthèse.
Lors de l’héritage, la nouvelle classe dérivée peut redéfinir les méthodes
héritées de la classe parente.
Dans une classe, on peur surcharger une méthode: On peut créer plusieurs
méthodes qui ont le même nom, mais avec des signatures différentes.
Dans une classe on peut également surcharger le constructeur: On peut
créer plusieurs constructeurs avec des signatures différentes.
Un constructeur peut faire appel à un autre constructeur dans la même
classe en utilisant le mot this suivi des valeurs des arguments entre
parenthèses.
Si vous ne définissez pas un constructeur dans votre classe, le compilateur
java définit un constructeur par défaut.
32
Abstract
Une classe abstraite est une classe incomplète. Elle regroupe un
ensemble de variables et de méthodes mais certaines de ses
méthodes ne contiennent pas d'instructions, elles devront être
définies dans une classe héritant de cette classe abstraite.
Une méthode déclarée abstract ne peut pas être exécutée. En fait,
elle n'a pas d'existence réelle. Sa déclaration indique simplement que
les classes dérivées doivent la redéfinir.
Ainsi, dans l'exemple Animaux, la méthode crie() de la classe
Animal aurait pu être déclarée abstract :
abstract void crie();
Une classe qui contient une méthode abstract doit être déclarée
abstract elle-même.
33
Exemple
abstract class Animal{
...
abstract void crie();
}
class Canari extends Animal {
....
void crie() {
[Link]("Cui-cui !");
}
}
class Chat extends Animal {
....
void crie() {
[Link]("miaou-miaou !");
}
}
34
Les Interfaces
Une classe peut contenir des méthodes abstract et des méthodes
non abstract.
Cependant, il existe une catégorie particulière de classes qui ne
contient que des méthodes abstract. Il s'agit des interfaces.
Les interfaces sont toujours abstract, sans qu'il soit nécessaire de
l'indiquer explicitement.
De la même façon, il n'est pas nécessaire de déclarer leurs
méthodes abstract.
35
Les Interfaces
Les interfaces obéissent par ailleurs à certaines règles
supplémentaires:
o Elles ne peuvent contenir que des variables static et final.
o Elles peuvent être étendues comme les autres classes, avec une
différence majeure : une interface peut dériver de plusieurs
autres interfaces.
o Une classe dérive toujours d'une autre classe et peut dériver, en
plus, d'une ou de plusieurs interfaces.
36
Exemples d’interfaces
public interface I1{ public interface I2{
public void A(); public void C();
public String B(); public String D();
} }
Pour faire en sorte qu'une classe utilise une interface, il suffit d'utiliser
le mot clé implements. Ce qui nous donnerait :
public class X implements I1{
public void A(){ //… }
public String B(){ //… }
}
37
Exemples d’interfaces
On peut aussi implémenter plusieurs interfaces
public class X implements I1, I2{
public void A(){
//…
}
public String B(){
//…
}
public void C(){
//…
}
public String D(){
//…
}
}
38
Merci pour votre attention
39
