Concepts de la

programmation orienté
objet (POO) en Java
Concepts élémentaires

 Encapsulation

 Classes, Objets et Identité

 Méthodes et attributs

 Constructeurs

 ….
 Encapsulation

• L’encapsulation consiste à réduire la visibilité des attributs et des

méthodes d'une classe, afin de n'exposer que les fonctionnalités
réellement nécessaires pour les classes utilisatrices.

• Cette réduction de visibilité est rendue possible avec :

– private : visibilité interne à la classe.

– public : visibilité pour toutes les classes.

– protected : visibilité pour les classes du même package et les

classes enfants (définies dans n’importe quel package).

– default (aucun des modes ci-dessus n’est spécifié) : visibilité

pour les classes du même package.
 Classes et Objets
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)

Exemple 1:
Fenêtre
position, taille, bordure, titre,
État
couleur,...
Comportement dessiner, déplacer, agrandir...
(Opérations)

Exemple 2:
Fichier
nom, répertoire, protections,
État
contenu, ...
Comportement
ouvrir, fermer, supprimer,
(Opérations)
 Classes et Objets (2)
Classe : Une classe c’est la description d’un ensemble d’objets ayant
une structure de données commune et disposant des mêmes
méthodes.

Exemple 1:
Personne
-Nom : String
-Prenom : String
-Age : int
+affiche() : void
+calculeAge() : int

Exemple 2:
Materiel
-Nom :String
-Prix : double
-Nombre : int
+affiche() : void
+achete() : void
 Classes et Objets (3)

Classe Instances

Personne -Nom : Meknassi

-Nom : String -Prenom :Ali
-Prenom : String -Age :23
-Age : int Instanciation
+affiche() : void -Nom : Kadiri
+calculeAge() : int -Prenom :Hamza
-Age :30
 Classes et Objets (4)

Syntaxe de déclaration d’une classe est :

public class Nom_de_la_classe

{
type1 p1; // propriété p1 Attributs
type2 p2; // propriété p2
…
type3 m3(…){ // méthode m3
…
} Méthodes
type4 m4(…){ // méthode m4
…
}
…
}
 Classes et Objets (5)
Exemple:

public class Point{

private int x ; // abscisse
private int y ; // ordonnee Attributs
public void initialise (int abs, int ord)
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy)
{ x += dx ;
y += dy ; Méthodes
}
public void affiche ()
{ System.out.println ("Je suis un point de coordonnees "
+ x + " " + y) ;
}
}
 Classes et Objets (6)

Méthodes ou fonctions membres: la définition d’une méthode se

compose d’un en-tête et d’un bloc.

public void initialise (int abs, int ord) En-tête

{ x = abs ;
y = ord ; Bloc
}

Remarque : L’ordre des méthodes dans une classe n’a pas

d’importance. Par exemple dans la classe Point on peut déclarer la
méthode affiche() puis la méthode deplace(), affiche() peut être
appelée sans problème dans deplace().
 Classes et Objets (7)

Utilisation d'une classe : Pour pouvoir utiliser une classe il faut

d’abord déclarer un objet, la déclaration est réalisée de la manière
suivante :

NomDeClasse NomDeVariable ;

//cette déclaration ne réserve pas d’emplacement pour un

objet de type Point,
Point a ;
//mais seulement un emplacement pour une référence à un
objet de type Point.
 Classes et Objets (8)
Pour créer une instance d’une classe, il faut utiliser l’opérateur new qui
se charge de créer une instance (ou objet) de la classe et de l’associer à
la variable. L’instanciation est réalisée par la façon suivante :

NomDeVariable = new NomDeClasse() ;

crée un emplacement pour un objet de type Point et

a = new Point() ;
fournit sa référence en a.
Il est possible de réunir les deux instructions en une seule :

NomDeClasse NomDeVariable = new NomDeClasse() ;

Crée une référence et un emplacement pour un

Point a = new Point() ; objet de type Point et fournit sa référence en a.
La situation peut être
a ? x
schématisée ainsi : ? y
 Classes et Objets (9)

On peut appliquer la méthode initialise (…) à l’objet référencié par a.

//appelle la méthode initialise (…) de la classe

a.initialise(3, 5) ; Point en l’appliquant à l’objet de référence a, et en
lui transmettant les arguments 3 et 5
La situation peut a 3 x
y
être schématisée 5

ainsi :

Pour employer notre classe Point, nous pouvons définir une

méthode main ou une méthode d’une autre classe.
 Classes et Objets (10)
Constructeur de classe : Un constructeur est une méthode particulière
dans une classe. Il porte le même nom que la classe, et permet d’allouer
la mémoire nécessaire à l'objet et d'initialiser ses attributs.
Exemple:
public class Point{
private int x ; // abscisse
private int y ; // ordonneé
public Point (int abs, int ord)
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy)
{ x += dx ;
y += dy ;
}
public void affiche ()
{ System.out.println ("Je suis un point de coordonneés " + x + " " + y) ;
}
}
 Classes et Objets (11)

Quelques règles concernant les constructeurs

 Un constructeur ne renvoie aucune valeur. Dans son en-tête,

aucun type ne doit figurer devant son nom. Même la présence
(logique) de void est une erreur.

 Une classe peut ne disposer d’aucun constructeur (c’était le cas de

notre première classe Point). On peut alors instancier des objets
comme s’il existait un constructeur par défaut sans arguments.

 Une classe peut avoir plusieurs constructeurs, qui seront

différenciés par leurs paramètres.

 Un constructeur est toujours appelé à l’aide de l’opérateur new.

 Classes et Objets (12)
Créations inutiles
• La création d'objets est coûteuse. Il faut éviter d'en créer inutilement :
Objet1 o1 = new Objet1();
Objet2 o2 = new Objet2(); L'un des objets ne sera
if(demande == 1) pas utilisé
o1.initialiser();
else
o2.initialiser();

if(demande == 1){
Objet1 o1 = new Objet1();
o1.initialiser();
}
else{
Objet2 o2 = new Objet2();
o2.initialiser();
}
 Classes et Objets (13)
Réutilisation d'objets
• Il faut proscrire la création d'objets à l'intérieur d'une boucle.
– Cette création peut être désastreux en terme de consommation de
la mémoire.
– Préférer la réutilisation d'objet, qui sera instancié avant la boucle,
et modifié à l'intérieur.

for(int i=0 ; i<employes.length ; i++){

Employe emp = new Employe(); //Création d'un objet à chaque passage
emp = (Employe) employes[i];
}

Employe emp = new Employe();

for(int i=0 ; i<employes.length ; i++){
emp = (Employe) employes[i]; //Réutilisation d'un seul objet Employe
}
 Classes et Objets (14)

La destruction d'objets

• L'un des objectifs du langage Java est d'affranchir le développeur

des problématiques de gestion de mémoire rencontrées par le C++.

• La gestion de la mémoire a donc été automatisée. Ce rôle est

délégué au "Garbage Collector" ou "ramasse-miettes".

– Il libère la mémoire des objets non utilisés, c'est-à-dire qui n'ont

plus de référence dans la pile de la mémoire.
 Classes et Objets (15)

Affectation et comparaison d’objets

Point a, b ; //déclaration de deux objets de type point

a 3 x
a = new Point(3,5); 5 y

b 2 x
b= new Point(2,0) 0 y

Si maintenant nous exécutons l’instruction d’affectation a=b ;

a 3 x
5 y
b 2 x
0 y
 Chaînes de caractères :
classe String
• Attention String n’est pas un type de base. Il s'agit d'une classe
défini dans l’API Java (package java.lang), permettant de manipuler
les chaines de caractères.
String s="salut"; // s contient la chaîne "salut"
String s=new String("salut"); // s contient aussi la chaîne "salut".
• La concaténation
– L’opérateur + entre deux String les concatène :
String str1 = "Bonjour ! ";
String str2 = "Comment vas-tu ?";
String str3 = str1 + str2; / * Concaténation de chaînes : str3
contient " Bonjour ! Comment vas-tu ? " */
 Classe String (2)

• Longueur d’une chaîne :

La méthode length () : donne la longueur d’une chaîne de

caractères (le nombre de caractères).
String s="salut";
int n= s. length ()//n contient la valeur 5.

• Recherche dans une chaîne

La méthode indexOf() : recherche une sous chaîne dans une chaîne

de caractères.
String ch1="Bonsoir", ch2="soir";
int p =ch1. indexOf(ch2); // p contient la valeur 3
 Classe String (3)

• Récupération d’un caractère dans une chaîne

– La méthode char charAt(int pos) : renvoie le caractère situé à
la position pos dans la chaîne de caractère à laquelle on envoie
ce message .
String str1 = "bonjour";
char c1= str1.charAt(3); // c1 contient le caractère 'j'

• Modification des objets String

– La méthode String substring() permet de modifier le contenu
de la variable contenant la chaîne (la variable ne référence
plus la même chaîne).
str1 = str1.substring(0,3) + "soir"; /* str1 contient
maintenant la chaîne "bonsoir" */
 Classe String (4)

• Les chaînes de caractères sont des objets :

– Si on veut tester si 2 chaînes sont égales, on utilise la méthode
boolean equals(String str)
– Si on veut tester si 2 chaînes sont égales à la casse près, on
utilise la méthode boolean equalsIgnoreCase(String str)
String str1 = "BonJour";
String str2 = "bonjour";
boolean a, b, c;
a = str1.equals("BonJour"); //a contient la valeur true
b = str1.equalsIgnoreCase(str2);//c contient la valeur true
c = "bonJour".equals(str2); //d contient la valeur false
 Classe String (5)

• La méthode split() : permet de découper une chaîne de caractères sur la

base d'un séparateur qui est exprimé sous la forme d'une expression
régulière.

public static void main(String [] args){

String chemin= "app\Elakkad\admin\orcl\fich.txt" ;
String [] elts;
String sepChemin= "/";
elts=chemin.split(sepChemin);
}

elts {"app", "Elakkad" , "admin", "orcl " , " fich.txt "}

 Classe String (6)
• Les objets de type « String » sont immuables. En effet, la variable de
type référence peut changer de valeur, et pointer vers une nouvelle chaîne
créée à un autre emplacement.
Bonjour
• String str= "Bonjour"; str
Tout le monde
str= "Tout le monde";

• L'avantage des objets immuables est qu’ils peuvent être partagés sans
risque. Mais si on utilise fréquemment ce type d’objets à l'intérieur des
boucles, par exemple, on peut avoir la création de plusieurs d'objets
(temporaires) avec un coût non négligeable (mémoires, temps
d'exécution).
• Dans ce cas, il est préférable de déclarer et utiliser des objets modifiables
qui sont de type StringBuffer ou StringBuilder.
 Classe StringBuffer
• Contrairement à la classe String, la classe StringBuffer permet de créer
des chaînes de caractères modifiables (la taille et le contenu peuvent
varier durant l'exécution de l'application).
• La notion de capacité représente la taille du buffer interne qui
mémorise la chaîne de caractères (nombre total de caractères
disponibles avant de devoir agrandir la taille du buffer interne).
• La capacité est automatiquement augmentée lorsque c'est nécessaire.
La capacité initiale peut être définie lors de la création d'un objet
StringBuffer (paramètre du constructeur, 16 par défaut).
• Ne pas confondre la capacité et la longueur d'un objet StringBuffer
 Classe StringBuffer (2)
• Pour créer un objet de type StringBuffer, on doit utiliser l’opérateur
new (…), car il n’y a pas de syntaxe simplifiée.
StringBuffer ch = new StringBuffer ("Bonjour")

• Création en définissant une capacité initiale

 Classe StringBuffer (3)
• Différentes méthodes permettent de manipuler les objets de type
StringBuffer:
 Le mot clé this
On utilise le mot clé this dans les circonstances suivantes :
1- Dans une méthode, this permet de référencer l'instance de l'objet en
cours d'utilisation. C’est un objet qui est égale à l'instance de l'objet
dans lequel il est utilisé.
Public class Point{ public class TestePoint
private int x ; // abscisse
{ public static void main (String [] args)
private int y ; // ordonnée
public Point (int abs, int ord) //constructeur { Point a, b;
{ x = abs ; y = ord ; } a = new Point(3, 5) ;
public Point doubleCoordonnees () a.affiche() ;
{Point p=new Point() ;
b=a.doubleCoordonnees() ;
p.x=2*this.x ; p.y= 2*this.y ;
return p ; } b.affiche()

public void affiche () }

{ System.out.println ("Je suis un point de }
coordonnées " + x + " " + y) ; }
}
Je suis un point de coordonnées 3 5
Je suis un point de coordonnées 6 10
 Le mot clé this (2)

2- Dans une méthode, this permet d'éviter les conflits des noms lorsque
les noms d’arguments d’une méthode et les variables locales sont
identiques à des noms d’attributs d’une classe.

Public class Point{

private int x ; // abscisse
private int y ; // ordonnée public class TestePoint
public Point (int x, int y) // constructeur
{ public static void main (String args[])
{
this. x =x; this.x fait référence à la variable { Point a ;
membre x alors que x fait référence
this.y = y; à la valeur de l'argument. a = new Point(3, 5) ;
}
a.affiche() ;
public void affiche ()
{ System.out.println ("Je suis un point de }
coordonnées " + this.x + " " + this.y) ; }
}
}
Je suis un point de coordonnées 3 5
 Le mot clé this (3)
3- Dans les classes définissant plusieurs constructeurs, un constructeur
peut invoquer un autre constructeur de cette classe par le mot clé this().

Public class Point {

private int x ; // abscisse
private int y ; // ordonneé
public Point (int x, int y) // constructeur public class TestePoint
{
this. x =x ; this.y = y ; { public static void main (String args[])
System.out.println("Constructeur avec 2 { Point a, b;
arguments "+x+" et "+y);
} a = new Point(3, 5) ;
public Point () // constructeur sans argument b= new Point() ;
{
this(0,0) ; }
System.out.println("Constructeur sans }
argument");
}
}
Constructeur avec 2 arguments 3 et 5
Constructeur avec 2 arguments 0 et 0
Constructeur sans argument
 Les accesseurs (les « getter » et les « setter »)
Un accesseur est une méthode publique qui donne l'accès à une propriété privée
d’une classe. L’accès peut être réalisé en lecture ou en écriture. Par convention,
les accesseurs en lecture commencent par get et sont appelés des getters
(accesseurs) et les accesseurs en écriture commencent par set et sont appelés
des setters (mutateurs).

Public class Point public class TestePoint

{private int x ; // abscisse
{ public static void main (String args[])
private int y ; // ordonneé
public Point (int x, int y)//constr. { Point a = new Point(3, 5) ; a.affiche() ;
{ this.x =x ; this.y =y ; } a.x=4 ;//interdit
public void deplace (int dx, int dy){ a.setX(4);//solution
x += dx ; y += dy ; }
a.affiche() ;
public int getX () { return x; }
public int getY() { return y; } int t=a.x ;//interdit
public void setX (int c) { x=c; } int t=a.getX();//solution
public void setY (int d) { y=d; }
System.out.println ("Je suis un point de
public void affiche () {
System.out.println ("Je suis un point coordonnées " + a.x + " " +a. y) ;//Interdit
de coordonnées " + x + " " + y) ; System.out.println ("Je suis un point de coordonnées
} " + a.getX() + " " +a. getY()) ;//Solution
} }}
 La surcharge de méthodes
La surcharge d'une méthode permet de définir plusieurs fois une même méthode
avec des arguments différents. Lors de l’appel de la méthode, le compilateur
choisit la méthode qui doit être appelée en fonction du nombre et du type des
arguments.
public class Point{
private int x ; // abscisse public class TestPoint
private int y ; // ordonnee { public static void main (String args[])
public Point (int x, int y) // constructeur
{ Point a = new Point (1, 2) ;
{ this. x =x ; this.y = y ; }
public void deplace (int dx, int dy) a.deplace (1, 3);//appelle deplace (int, int)
//deplace (int, int) a.deplace (2) ; // appelle deplace (int)
{ x += dx ; y += dy ; }
short p = 3 ;
public void deplace (int dx)// deplace (int)
{ x += dx ; } a.deplace (p) ; // appelle deplace (short)
public void deplace (short dx)//deplace (short) byte b = 2 ;
{ x += dx ; }
a.deplace (b) ; // appelle deplace (short)
public void affiche ()
{ System.out.println ("Je suis un point de // après conversion de b en short
coordonnees " + this.x + " " + this.y) ; }
} }
}
concepts avancés

 Héritage entre classes

 Polymorphisme

 Interfaces

 Classes abstraites

…
 Héritage
Caractéristiques de l’héritage
L'héritage est une propriété importante de la programmation orientée
objet Java.
 Ce concept permettant d'ajouter des nouvelles fonctionnalités à une
classe à partir de la création d’une sous-classe héritant des propriétés
de la classe de base et à laquelle s’ajoutent des nouvelles propriétés.
 La classe héritée s’appelle sous-classe (classe dérivée) de la classe
mère (super-classe).
 L'héritage permettant à une classe dérivée d'étendre les propriétés de
la classe de base tout en héritant des attributs et des méthodes de cette
classe de base.
 L’héritage en Java, ne permet à une classe d’hériter que d'une seule
classe de base, on parle d’héritage simple. En effet, pas d’héritage
multiple.
 Héritage (2)
Toutes les classes Java dérivent automatiquement d'une seule et
même classe ancêtre : la classe Object.
Donc, l’héritage permet de définir une nouvelle classe à partir d’une
classe existante, à laquelle on ajoute de nouvelles données et
méthodes.

Exemple 1:
Personne
-Nom : String
-Prenom : String
-Age : int
+affiche() : void
+calculeAge() : int

Etudiant Enseignant
-cne : int -ppr: int
+affiche() : void +affiche() : void
 Héritage (3)
Exemple 2:
L'héritage induit une relation arborescente entre les classes.

En notation UML, le symbole

Materiel
Signifie "est une sous-classe
MaterielInfo de " ou "hérite de"

Scanner Imprimante «MaterielInfo» joue

plusieurs rôles

- La classe «Materiel » est la classe mère de «MaterielInfo».

- La classe «MaterielInfo» est la classe mère de «Scanner» et «Imprimante».
- La classe «MaterielInfo» est une sous-classe de «Materiel ».
- «Scanner» et «Imprimante» sont des sous-classes de «MaterielInfo» .
 Héritage (4)

Exemple 3: classe «Vehicule»

Dans le but d’exprimer le concept de l’héritage, on traitera un exemple

d'une classe « Vehicule » décrivant, très sommairement, les propriétés et
les comportements d'un véhicule du monde réel.

La modélisation simple de cette classe est représentée comme suit:

Vehicule
marque
couleur
vitesse
etat
demarrer()
arreter()
accelerer()
freiner()
 Héritage (5)
Définition de la classe Vehicule
public class Vehicule {
private String marque;
private String couleur;
private double vitesse; // Vitesse actuelle
private int etat; // 0:arrêt, 1:marche, ...
public Vehicule(String marque, String couleur) {
this.marque = marque;
this.couleur = couleur;
vitesse = 0.0;
etat = 0;
}
public void demarrer() { etat = 1; }
public void arreter() { if (vitesse == 0) etat = 0; }
public void accelerer() {if (etat == 1) vitesse += 5.0;}
public void freiner() {
if (vitesse >= 5.0) vitesse -= 5.0;
else vitesse = 0.0;}
}
 Héritage (6)
Classes dérivées de « Vehicule »
De nouvelles classes « Voiture » et « Camion » peuvent être crées, en utilisant
l'héritage, à partir de « Vehicule ». Elles la spécialisent en y ajoutant de nouvelles
propriétés.
Un tel diagramme, dans le langage UML, est appelé "Diagramme de classes". Il
montre les relations entre les classes d'une application.
Vehicule
marque
couleur
vitesse
etat
demarrer()
arreter()
accelerer()
freiner()

Camion Voiture
chargeMax modele
poidsChargement nbPortes
charger()
decharger()
 Héritage (7)
Classes dérivées: Camion et Voiture
La classe Camion est une classe dérivée de Vehicule. Elle hérite tous ses
méthodes et attributs. Elle étend la classe mère Vehicule en lui ajoutant deux
nouveaux attributs chargeMax et poidsChargement, ainsi que deux
nouvelles méthodes charger() et decharger()).
La classe Voiture est une classe dérivée de Vehicule et hérite tous les
méthodes et les attributs de Vehicule en lui ajoutant deux nouveaux attributs
modele et nbPortes.
On peut utiliser, dans les classes dérivées Camion et Voiture, les attributs
et les méthodes héritées (par exemple couleur ou freiner()) comme si ces
membres ont été déclarés dans chacune des sous-classes (sous réserve,
naturellement, que les droits d'accès le permettent).
 Héritage (8)
Implémentation de la classe Voiture
La déclaration d'une classe dérivée se fait en utilisant le mot clé «extends»
suivi du nom de la classe de base.
Lorsque le mot «extends» est omis, alors la classe hérite automatiquement
de la classe « Object ».

public class Voiture extends Vehicule {

private String modele; // Nouveau attribut
private int nbPortes; // Nouveau attribut
public Voiture(String marque, String modele, String couleur, int nbPortes)
{ super(marque, couleur); // Appel au constructeur de la classe mère
this.modele = modele;
this.nbPortes = nbPortes;
}
}
 Héritage (9)
Exemple 4: Classe de base Point et sa classe dérivée PointCol

Public class Point{

private int x ; // abscisse
private int y ; // ordonneé
public Point () // constructeur par défaut
{ this. x =0 ; this.y = 0 ; } public class PointCol extends Point{
public Point (int x, int y) private int couleur ;
{ this. x =x ; this.y = y ; } public void colore (int c) {
public void deplace (int dx, int dy) couleur = c ;
{ x += dx ; y += dy ; } }
public void affiche () }
{ System.out.println ("Je suis un point de
coordonnees
" + this.x + " " + this.y) ; }
}
 Héritage (10)

public class TestePointCol

{ public static void main (String args[]){
PointCol pc = new PointCol() ; // constructeur par défaut de PointCol
Point p = new Point(4,5);
pc.deplace(4, 5) ; // correct car ‘deplace’ est héritée
pc.colore(6) ; // correct
Point p1 = new PointCol() ;
p1.colore(9) ; // ERREUR ! l’héritage ne marche pas dans ce sens !
}
}
 Héritage (11)
Appel des constructeurs : un constructeur d’une classe dérivée peut
appeler un constructeur de sa classe de base. Il suffit de transmettre les
paramètres du constructeur de la sous-classe au constructeur de la
super-classe. Ceci est fait par le mot-clé super.

Public class Point{

private int x ; // abscisse class PointCol extends Point {
private int y ; // ordonnee public int couleur;
public Point (int x, int y) // constructeur public PointCol(int x, int y, int couleur)
{
this. x =x ; {
this.y = y ; super (x, y) ; // appel au constructeur de
} la super-classe
public void deplace (int dx, int dy)
this.couleur = c ;
{ x += dx ; y += dy ; }
public void affiche () }
{ System.out.println ("Je suis un point de ...
coordonnees " + this.x + " " + this.y) ;
}
}}
 Héritage (12)
Accès d’une classe dérivée aux membres de sa classe de base
Si un champ d'une classe dérivée porte le même nom qu'un champ d'une
classe de base, alors :
Le champ dérivé masque le champ de base.
Un code de la classe dérivée peut lire le champ de la classe de base en
utilisant le mot-clé super.
Le code de la classe de base n’accède pas au champ de sa classe dérivée
Exemple 1:
public class A {
protected String nom = "Je suis dans A" ;
public void uneMethode() {
System.out.println(nom) ; // affiche "Je suis dans A"
}}
public class B extends A {
protected String nom = "Je suis dans B" ;
public void uneAutreMethode() {
System.out.println(nom) ; // affiche "Je suis dans B"
System.out.println(super.nom) ; // affiche "Je suis dans A"
}}
 Héritage (13)
Accès d’une classe dérivée aux membres de sa classe de base (2)
Exemple de test
public class Main {
public static void main(String []args) {
A a = new A() ; // la classe A est celle que nous venons de définir
B b = new B() ;
System.out.println("a.nom = " + a.nom) ;
System.out.println("b.nom = " + b.nom) ;
a.uneMethode();
b.uneAutreMethode();
}}
Résultat d’exécution
a.nom = Je suis dans A
b.nom = Je suis dans B
Je suis dans A
Je suis dans B
Je suis dans A
 Héritage (14)
Accès d’une classe dérivée aux membres de sa classe de base (3)
Une méthode d’une classe dérivée n’a pas accès aux membres privés de
sa classe de base.
Exemple : on cherche à doter dans la sous-classe PointCol, de la classe
Point, la méthode afficheCouleur qui permet d’afficher les coordonnées
du point et la couleur.
Public class Point{ public class PointCol extends Point{
private int x ; // abscisse
private int couleur ;
private int y ; // ordonnée
public Point (int x, int y) // constructeur public PointCol( int x, int y, int couleur){
//par arguments super(x, y); this.couleur=couleur;} Erreur : x et y
{ public void afficheCouleur() { sont privées
this. x =x ; this.y = y ; }
System.out.println ("Je suis en " + x + " " + y);
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; } System.out.println (" et ma couleur est : " +
public void affiche () couleur) ;
{ System.out.println ("Je suis un point de
}
coordonnees " + this.x + " " + this.y) ;
} public void colore (int c) { couleur = c; }
} }
 Héritage (15)

Accès d’une classe dérivée aux membres de sa classe de base (4)

Une méthode d’une classe dérivée a accès aux membres publics de sa

classe de base.

Exemple : pour écrire la méthode afficheCouleur, nous pouvons nous

appuyer sur la méthode affiche de Point en procédant ainsi :

public void afficheCouleur ()

{
affiche() ;//équivalent de this.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
 Héritage (16)
Redéfinition des méthodes

On appelle redéfinition d’une méthode, la possibilité de définir le

comportement d’une méthode selon le type d’objet l’invoquant, c.-à-
d., de donner une nouvelle implémentation à une méthode héritée
sans changer sa signature.

Exemple 1

public void affiche ( )

{
super. affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
 Héritage (17)

Exemple 2

public class Polygon {

...
public double area() {
. . . // Calcul de la surface d'un polygone quelconque
}
...
}
public class Rectangle extends Polygon {
...
public double area() {
. . . // Calcul de la surface du rectangle (longueur*largeur)
}
...
}
 Héritage (18)
Les classes « Polygone » et « Rectangle » définissent toutes les deux
une méthode area() avec une signature identique.
La méthode invoquée par un appel obj.area() dépendra du type de
l'objet référencé par la variable obj lors de l'exécution de cette
instruction.
 C'est toujours la méthode associée au type effectif de l'objet
référencé qui est exécutée, même si l'objet est enregistré dans une
variable déclarée avec le type d'une classe parente :

Rectangle r = new Rectangle();

Polygon p = r; // Conversion implicite
double s = p.area(); //Invoque r.area() et non pas area() de la classe Polygon
// car la variable p référence un objet de type Rectangle
 Héritage (19)

Dans la sous-classe Rectangle, il est possible d'invoquer la méthode

area() de la classe parente Polygon en utilisant la notation suivante :
super.area()

Remarque : La notation super.super.f() n'est pas autorisée et il est

impossible d'accéder à une méthode masquée d'une classe ancêtre
(autre que la classe parente).

 A l'extérieur de la classe de déclaration il n'est, par contre, pas

possible pour un objet de type Rectangle, d'invoquer la méthode
area de la classe Polygon.

 Attention, il faut bien distinguer la différence entre la surcharge et

de redéfinition de méthodes.
 Héritage (20)
Si une méthode est redéfinie dans une sous-classe, le type de retour doit
être identique à celui de la méthode correspondante de la classe parente.
En redéfinissant une méthode, il est possible d'étendre sa zone de visibilité
(private  package  protected  public), mais non de la restreindre.
Exemple:
public class A {
private void fonction(float v) { ……}
}
public class B extends A {
public void fonction(float v){…}//redéfinition avec extension des droits d’accès.
}
Une méthode redéfinie ne peut pas générer plus d'exceptions contrôlées que
celles qui sont déclarées dans la méthode de la classe parente (mais elle peut
en déclarer moins).
Éviter de :
 Surcharger une méthode qui est redéfinie
 Redéfinir une partie des méthodes surchargées
Car cela provoque des risques de confusion et crée des pièges lors des
modifications ultérieures des classes.
 L’opérateur instanceof
L'opérateur instanceof permet de vérifier si une référence d‘un objet est
une instance d'une certaine classe ou interface.

Exemple 1 : public class TestPoint

Public class Point { { public static void main (String args[])
private int x ; // abscisse { Point a =new Point(1,2);
private int y ; // ordonneé if(a instanceof Point)
public Point (int x, int y)//constructeur System.out.println("l’objet « a » est
{ une instance de la classe Point");
this. x =x ; else
this.y = y ; System.out.println("l’objet « a » n’est
pas une instance de la classe Point ");
} }
} }

l’objet « a » est une instance de la classe point

 L’opérateur instanceof (2)
Exemple 2:
class B{ …}
class D extends B{…}
class C {…}
B b = new B();
D d = new D();
C c = new C();
b instanceof B // true
b instanceof D // false
d instanceof B // true
d instanceof D // true
b = d;
b instanceof B // true
b instanceof D // true
c instanceof B//erreur de compilation, impossible de comparer C avec B