PROGRAMMATION

ORIENTEE OBJET
Présenté par : Makrem Mhedhbi
 L’ENCAPSULATION

Le confusion est fréquente dans la littérature française entre

information-hiding et encapsulation, mais ce dernier
concept est différent de l'encapsulation :
•l'encapsulation vise à regrouper les données et leur
traitements;
•l'information-hiding vise à cacher les détails
d'implémentation et à ne permettre l'accès à un objet qu'au
travers d'une interface bien définie.

CHAPITRE 3 2
 L’ENCAPSULATION
Ainsi, un langage orienté objets comme Java ou C++ met en
œuvre l'encapsulation en permettant de créer des classes qui
regroupent les attributs et les méthodes associées.
Dans ces mêmes langages, l'information-hiding est mis en
œuvre (de façon totalement optionnelle - à la discrétion du
programmeur) par l'utilisation des
modificateurs private ou public (entre autres).
Dans la pratique une conception orientée objets moderne fait
intervenir conjointement ces deux principes

CHAPITRE 3 3
 L’ENCAPSULATION
• Le principe d'encapsulation : un objet ne doit pas exposer sa
représentation interne au monde extérieur.
• Dans le but de renforcer le contrôle de l'accès aux variables d'une
classe, il est recommandé de les déclarer private.
• L'objet est ainsi vu de l'extérieur comme une boîte noire
• Protéger l'information contenue dans un objet et ne proposer que
des méthodes de manipulation de cet objet

CHAPITRE 3 4
 Les Packages
Projet • Package = repertoire.
package 1
• Les classes Java peuvent être regroupées dans
des packages.
ClassA
• Déclaration d’un package
ClassB
package pack1;
Package 2 • Import d’un package

ClassC import pack2.ClassC;

ClassD
import pack2.*;
Package 21

ClassE

CHAPITRE 3 5
Encapsulation des classes

CHAPITRE 3 6
 Encapsulation des classes
Classe public :

public class A {

…
}

class B { class C extends A { class D {

A a; A a; A a;
… … …
} } }

• La classe public est visible depuis n’importe quelle classe du projet.

CHAPITRE 3 7
 Encapsulation des classes
Default classe

class A {

…
}

class B { class C extends A { class D {

A a; A a; A a;
… … …
} } }

• La classe default est visible seulement par les classes de son package.
CHAPITRE 3 8
Encapsulation des attributs

CHAPITRE 3 9
 Encapsulation des attributs
L’attribut public

public class A {
public int x;

…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a. x = t ; a. x = t ; a. x = t ;
} } }

• La variable public est visible par toutes les classes

CHAPITRE 3 10
 Encapsulation des attributs
L’attribut private

public class A {

…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a. y = t ; a. y = t ; a. y = t ;
} } }

• La variable private n'est accessible que depuis l'intérieur même de la classe.

CHAPITRE 3 11
 Encapsulation des attributs
L’attribut par défaut : package friendly

public class A {

…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a.z= t ; a. z = t ; a. z = t ;
} } }

• La variable par défaut n'est accessible que depuis les classes faisant partie du même package.
CHAPITRE 3 12
 Encapsulation des attributs
L’attribut protected

public class A {

…
protected int w ;

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a.w= t ; a.w= t ; a. w = t ;
} } }
• La variable protected est accessible uniquement aux classes d'un package et à
ses sous-classes (même si elles sont définies dans un package différent.)
CHAPITRE 3 13
Encapsulation des méthodes

CHAPITRE 3 14
 Encapsulation des méthodes
Méthode public

public class A {
public void meth1()
{ }
…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a.meth1() ; a.meth1() ; a.meth1() ;
} } }

La méthode public est visible par toutes les classes

CHAPITRE 3 15
 Encapsulation des méthodes
Méthode private

public class A {
private void meth2 ()
{ }
…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a.meth2() ; a.meth2() ; a.meth2() ;
} } }

La méthode private n'est accessible que depuis l'intérieur même de la classe.

CHAPITRE 3 16
 Encapsulation des méthodes
Méthode par défaut : package friendly

public class A {
void meth3 () {}
…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a.meth3() ; a.meth3() ; a.meth3() ;
} } }

La méthode par défaut n'est accessible que depuis les classes faisant partie du même
package.
CHAPITRE 3 17
 Encapsulation des méthodes
Méthode protected

public class A {
Protected void meth4()
{}
…
}

class B { class C extends A { class D {

A a=new A(); A a=new A(); A a=new A();
a.meth4() ; a.meth4() ; a.meth4() ;
} } }

La méthode protected est accessible uniquement aux classes d'un package et à ses sous-
classes (même si elles sont définies dans un package différent.)
CHAPITRE 3 18
 Les attributs static
Etudiant [class]

Variable d’instance:
Chaque instance de la classe possède
ses propres valeurs des variables.

Etudiant [instance] Etudiant

Class Etudiant { [instance]

String nom;

Etudiant(String nom){
Mohamed Anissa
this.nom=nom;
}
} Etudiant etud1 = new Etudiant (“Mohamed");
Etudiant etud2 = new Etudiant (“Anissa ");
CHAPITRE 3 19
 Les attributs static
Variable d’instance:
Class Etudiant {
String nom;

Etudiant(String nom){
this.nom=nom;
} class Test {
} public static void main(String[] args){

Etudiant etudiant =new Etudiant();

System.out.println(etudiant.nom);
}
}

On invoque les variables d’instance avec le nom de l’instance

CHAPITRE 3 20
 Les attributs static
Variable de classe: Etudiant [class]
• n'appartient pas à une instance particulière
• elle appartient à la classe.
• elle est partagée par toutes les instances de la
classe
Etudiant [instance]
Etudiant [instance]
Class Etudiant {

String nom; Mohamed

Anissa
static int nbrEtudiants;
Etudiant [instance]
Etudiant(String nom){
this.nom=nom;
Kamel
nbrEtudiants++;
} Etudiant etud1 = new Etudiant (“Mohamed ");
} Etudiant etud2 = new Etudiant (“Anissa ");
Etudiant etud3 = new Etudiant (“Kamel ");
CHAPITRE 3 21
 Les attributs static
Variable de classe:

class Etudiant{
String nom;
static int nbrEtudiants;
class Test{
Etudiant(String nom){ public static void main(String[] args){
this.nom=nom;
nbrEtudiants++; System.out.println(Etudiant.nbrEtudiants);
}
} }
}

On invoque les variables static avec le nom de la classe

CHAPITRE 3 22
 Les méthodes static

Le comportement d’une méthode statique ne dépend pas de la valeur des

variables d'instance

class MaClassMath { Utilisation:

L'appel à une méthode statique se fait en
static int min(int a , int b){ utilisant le nom de la classe.
if(a<b){
return a;
}else{ class Test {
return b; public static void main ( String [] args ){
} int x = MaClassMath .min (21 ,4);
} }
} }

CHAPITRE 3 23
 Les méthodes static
Puisque les méthodes static appartiennent à la classe, elles ne peuvent en aucun cas
accéder aux variables d'instances qui appartiennent aux instances de la classe.

• Les méthodes d’instances accèdent aux variables d’instance et méthodes

d’instances
• Les méthodes d’instances accèdent aux variables de classe (static) et méthodes de
classe (static)
• Les méthodes de classe (static) accèdent aux variables de classe (static) et
méthodes de classe (static)
• Les méthodes de classe (static) n’accèdent pas aux variables d’instance et
méthodes d’instance

on ne3 peut pas utiliser this

Dans une méthode static CHAPITRE 24
 Les méthodes static
class StaticExemple {
// méthode non-static
int multiply(int a, int b){ return a * b; }
// méthode static
static int add(int a, int b){ return a + b; }
}
public class Main {
public static void main( String[] args ) {
// create an instance of the StaticTest class
StaticExemple st = new StaticExemple ();
// call the nonstatic method
System.out.println(" 2 * 2 = " + st.multiply(2,2));
// call the static method
System.out.println(" 2 + 3 = " + StaticExemple .add(2,3));
}
}

CHAPITRE 3 25
 L’héritage

 Savoir identifier le lien entre les classes

 Introduire la technique d’héritage : intérêt et notation .
 Introduire les droits d’accès d’une classe dérivée aux
membres de la classe de base.
 Comprendre la construction d’un objet dérivé
 Maîtriser la notion de redéfinition.

CHAPITRE 3 26
 L’héritage
Définition:
 Technique offerte par les langages de programmation pour construire une
classe à partir d’une (ou plusieurs) autre classe en partageant ses attributs et
opérations.
Intérêts :
 Spécialisation, enrichissement : une nouvelle classe réutilise les attributs et
les opérations d’une classe en y ajoutant des opérations particulières à la
nouvelle classe
 Redéfinition : une nouvelle classe redéfinit les attributs et opérations d’une
classe de manière à en changer le sens et/ou le comportement pour le cas
particulier défini par la nouvelle classe
 Réutilisation : évite de réécrire du code existant et parfois on ne possède pas
les sources de la classe à hériter CHAPITRE 3 27
 Pourquoi hériter ?

 Pour relier des classes entre elles:

 Lorsqu’une classe étend les fonctionnalités d’une autre classe
 Lorsqu’une classe adapte le fonctionnement d’une autre classe à une
situation particulière.
 Pour exploiter des classes existantes sans en modifier le code
même si ce code est inaccessible.
 La documentation de la classe héritée suffit pour organiser le
développement.
 Regrouper les champs et les méthodes communs à plusieurs
classes.

CHAPITRE 3 28
 Classes et Sous classes
Un objet de la classe VehiculePrioritaire ou VoitureElectrique est aussi un objet de
la classe Voiture donc il dispose de tous les attributs et opérations de la classe
Voiture.

CHAPITRE 3 29
 Classes et Sous classes
Définitions :
 La classe VehiculePrioritaire hérite de la classe Voiture.
 Voiture est la classe mère et VehiculePrioritaire la classe fille.
 Voiture est la super-classe de la classe VehiculePrioritaire.
 VehiculePrioritaire est une sous-classe de Voiture.
N.B :
 Un objet de la classe VehiculePrioritaire ou VoitureElectrique est forcément un objet
de la classe Voiture.

 Un objet de la classe Voiture n’est pas forcément un objet de la classe

VehiculePrioritaire ou VoitureElectrique.

CHAPITRE 3 30
 Généralisation et Spécialisation

La généralisation exprime une relation « est-un » entre une classe et sa super-

classe.

L’héritage permet
 De généraliser dans le sens abstraction
 De spécialiser dans le sens raffinement
CHAPITRE 3 31
 Héritage et JAVA
Héritage simple
 Une classe ne peut hériter que d’une seule autre classe
 Dans certains autres langages (ex : C++) possibilité d’héritage multiple
 Utilisation du mot-clé extends après le nom de la classe

Voiture public class VehiculePrioritaire extends Voiture {

private boolean gyrophare;
...
public void allumeGyrophare() {
gyrophare = true;
VehiculePrioritaire }
- gyrophare : boolean ...
+ allumeGyrophare () }
CHAPITRE 3 32
 Héritage à plusieurs niveaux
public class Voiture {
...
public void demarre() {
Voiture ...
+ demmarer }
}

public class VehiculePrioritaire extends

Voiture {
...
public void allumeGyrophare() Ambulance am = new
VehiculePrioritaire { Ambulance(...);
+ allumeGyropahre ... am.demarre();
} am.allumeGyrophare();
} am.chercher(“Lotfi");

public class Ambulance extends

VehiculePrioritaire {
Ambulance private String malade;
- malade : String ...
+ chercher (String)
public void chercher(String ma) {
...
}
} CHAPITRE 3 33
 Surcharge et Redéfinition
L’héritage
 Une sous-classe peut ajouter des nouveaux attributs et/ou méthodes à ceux
qu’elle hérite (surcharge en fait partie).
 Une sous-classe peut redéfinir (redéfinition) les méthodes à ceux dont elle
hérite et fournir des implémentations spécifiques pour celles-ci.
Surcharge : possibilité de définir des méthodes possédant le même nom, à
condition d’avoir des signatures différentes (signature : nombre et types
d’arguments. Qu’en est-il pour la valeur de retour ?).

CHAPITRE 3 34
 Surcharge et Redéfinition
 Une voiture électrique est une voiture dont l’opération de démarrage est
différente
 Une voiture électrique répond aux même messages que la Voiture
 On démarre une voiture électrique en activant un disjoncteur
Voiture public class VoitureElectonique extends Voiture {
+ demarre() private boolean disjoncteur;
...
public void demarre() {
disjoncteur = true;
}
VoitureElectrique ...
- disjoncteur : boolean }
+ demarre() Redéfinition de la méthode
CHAPITRE 3 35
 Surcharge et Redéfinition
public class Voiture {
Ne pas confondre surcharge et
… redéfinition. En surcharge la classe
public void demarre() { ajoute des méthodes de même nom,
… tandis que la redéfinition «spécialise»
}
}
des méthodes existantes dans la classe
mère
Redéfinition Surcharge
public VehiculePriotitaire extends Voiture{
public VoitureElectonique extends Voiture{ …
… public void demarre(int code)
public void demarre() { {
… …
} }
} }

CHAPITRE 3 36
 Méthodes et Classes final
Définition
• Utilisation du mot-clé final
• Méthode : interdire une éventuelle redéfinition d’une méthode

public final void demarre();

• Classe : interdire toute spécialisation ou héritage de la classe concernée

public final class VoitureElectrique extends Voiture {

...
}

La classe String est finale (wrapper class)

CHAPITRE 3 37
 Héritage et constructeurs
Possibilité comme les méthodes de réutiliser le code des constructeurs de la super-classe
 Appel explicite d’un constructeur de la classe mère à l’intérieur d’un constructeur de la
classe fille

 Utilise le mot-clé super

L’appel au constructeur de la superclasse
doit se faire absolument en première
instruction

super(paramètres du constructeur);

 Appel implicite d'un constructeur de la classe mère est effectué quand il n'existe pas d'appel
explicite. Java insère implicitement l'appel super()
CHAPITRE 3 38
 Héritage et constructeurs
Pour initialiser les attributs hérités, le constructeur d’une classe peut invoquer un des constructeurs de la classe
mère à l’aide du mot-clé super.

public class VoitureElectrique extends Voiture{

public VoitureElectrique( int puissance, boolean estDemarer, float vitesse) {

super(puissance, estDemarer,vitesse) ; super doit être la première

instruction
}
}
--------------------------------------------------------------------------------
public Voiture( String unNom) {

this (puissance, estDemarer,vitesse) ;

Si on ne fait pas d’appel explicite au constructeur de la superclasse, c’est le constructeur par défaut de la
superclasse qui est appelé implicitement. CHAPITRE 3 39
 Héritage et constructeurs
Règles

1. L’appel d’un constructeur de la classe mère doit être la

première instruction du constructeur de la classe fille.

2. Il n’est pas possible d’utiliser à la fois un autre constructeur

de la classe et un constructeur de sa classe mère dans la
définition d’un de ses constructeurs.

public class A {

INTERDIT
public A ( int x) {
super();
this() ;
}
} CHAPITRE 3 40
 Héritage et constructeurs
Constructeur implicite :

public class B extends A {

public B( int x ) { Si on ne fait pas d’appel explicite au

// appel super ( ) implicite constructeur de la superclasse, c’est le
this . x = x ; constructeur par défaut de la superclasse qui
... est appelé implicitement.
}
}

Attention :
Dans ce cas, le constructeur sans argument doit être défini dans la super-classe

CHAPITRE 3 41
 La classe Object
• La classe Object est la classe de plus haut niveau dans la hiérarchie d'héritage.
• Toute classe autre que Object possède une super-classe
• Toute classe hérite directement ou indirectement de la classe Object
• Une classe qui ne définit pas de clause extends hérite de la classe Object

* Voiture
public class Voiture extends Object {
... + Class getClass()
public Voiture(int p, Galerie g) + String toString()
{ + boolean equals(Object)
puissance = p; + int hashCode()
moteur = new Moteur(puissance);
…
galerie = g;
...
} Il n'est pas nécessaire d'écrire
...
explicitement extends Object
} CHAPITRE 3 42
 La classe Object

 En Java, la racine de l’arbre d’héritage des classes est la classe

java.lang.Object

 La classe Object n’a pas de variable d’instance ni de

variable de classe.

 La classe Object fournit plusieurs méthodes qui sont héritées par toutes
les classes sans Exception.
 Les plus couramment utilisées sont les méthodes toString et equals
CHAPITRE 3 43
 Chainage des constructeurs
• Concernant le codage des constructeurs, le compilateur JAVA
applique trois règles très importantes, reflétant les capacités de JAVA
et les situations d’erreur de compilation :
• Règle 1 : Si la classe définie n’hérite pas explicitement, le compilateur
ajoute un héritage de la classe java.lang.Object.
• Règle 2 : Si la classe ne contient aucun constructeur, le compilateur
JAVA ajoute un constructeur non paramétré (par défaut).
• Règle 3 : Si la première ligne d’un constructeur n’est ni this(…) ni
super(…), le compilateur ajoute super().

CHAPITRE 3 44
 Chainage des constructeurs
• Tout constructeur, sauf celui de la classe java.lang.Object, fait appel à un
autre constructeur qui est :

- un constructeur de sa superclasse (appelé par super(...)) ;

- un autre constructeur de la même classe (appelé par this(...)).

• Cet appel est mis nécessairement en première ligne du constructeur.

• En cas d'absence de cet appel, le compilateur ajoute super(); en première

ligne du constructeur.

CHAPITRE 3 45
 Chainage des constructeurs
▪ public class A { ▪ public class B extends A { ▪ public class C extends B {

public A() { public B(){ public C() {

System.out.println("constructeur de A"); System.out.println("constructeur de B"); super(3);
} System.out.println("constructeur de C");
} }
} }
public B(int r){
this(); ▪ public class EssaiChainage {
System.out.println( "autre constructeur public static void main(String[]
de B"); argv) {
} new C();
}
} }

CHAPITRE 3 46
 Chainage des constructeurs
Affichage:

constructeur de A
constructeur de B
autre constructeur de B
constructeur de C

Explication:
Peut-être avez-vous oublié constructeur de A, si vous n'avez plus pensé que
l'instruction super(); est ajoutée en première ligne du constructeur sans
paramètre de la classe B.

L'instruction super(); est aussi ajoutée en première ligne du constructeur de

la classe A , faisant ainsi appel au constructeur sans paramètre de la classe
Object, mais ce constructeur ne fait rien.
CHAPITRE 3 47
 Chainage des constructeurs
▪ public class Person {
private String name; ▪ public class Student extends Person {
public Person(String n) {
this.name=n; public Student(){
public class
System.out.println(#1); this(‘student’); EssaiChainage {
} System.out.println(#2);
}
public static void
} main(String[] argv) {
public Student (String n){
super(n); Student s = new Student()
System.out.println( #3);
}
}
}
}

CHAPITRE 3 48
 Polymorphisme
• N’importe quel objet en Java qui peut passer d’une
relation « est un » peut être considéré polymorphe.

• Le polymorphisme est le fait qu’une même

écriture peut correspondre à différents appels de
méthodes

CHAPITRE 3 49
 Polymorphisme
• Le polymorphisme est le fait de référencer une classe fille avec une référence déclaré
de type une classe mère.

• Exemple: Animal

Animal myDog = new Dog();

Référence déclaré en
Objet crée en Dog
tant qu’Animal().
tant que Dog().

CHAPITRE 3 50
 Polymorphisme
Avec le polymorphisme : le type de la référence peut être la classe mère de
l’objet instancié.
un tableau polymorphique.
Animal
Soit : Animal [ ] animals = new Animal [3];
 Déclarer un tableau de type Animal.
 Un tableau qui contiendra des objets
de type Animal.

Dog Cat Wolf

animals [0] = new Dog();

animals [1] = new Cat();

animals [2] = new Wolf();

CHAPITRE 3 51
Polymorphisme : Tableau

CHAPITRE 3 52
Polymorphisme : Tableau

CHAPITRE 3 53
 instanceof

- Si x est une instance d’une sous-classe B de A

 x instanceof A renvoie true

- Pour tester si un objet o est de la même classe que l’objet courant, il ne

faut donc pas utiliser instanceof mais le code suivant :

if (o != null && o.getClass() == this.getClass())

CHAPITRE 3 54
 Polymorphisme au runtime
Animal
Animal animal = new Dog();

public void eat(){

sout(’’je manges’)
}
animal.eat(); public void roam(){
sout(’’je voyages’)
}

Dog

Lorsqu’une méthode d’un objet est accédée à public void eat(){

sout(’’Un chien mange’’)
travers une référence “surclassée” (animal), }
public void roam(){

c’est la méthode définie au niveau de la }

sout(’’Un chien voyage’’)

classe réelle (Dog) de l’objet qui est public void watch(){

sout(’’je gardes’)
invoquée et exécutée (« Un chien mangeCHAPITRE
») 3 }
55
 Polymorphisme : Méthode appellée
Animal
Wolf w = new Wolf();
• Quand vous appelez une méthode d’un objet
makeNoise()
référencé, vous appelez au fait la méthode la plus eat()
spécifique du type de cet objet. w.makeNoise(); sleep()
roam()

• Le type le plus inférieur gagne ! w.roam();

(inférieur : dans l’arbre d’héritage.) w.eat(); Canine
w.sleep();
roam()

• La machine virtuelle JVM commence tout d’abord à

voir dans la classe Wolf . Si elle ne trouve pas une Wolf
correspondance de la version de la méthode,
makeNoise()
elle commence à grimper l’hiérarchie de l’héritage eat()
jusqu’à trouver la bonne méthode. CHAPITRE 3 56
 EXERCICE
• Dans le package geometrie :
• Créer la classe Forme en se basant sur la classe Point développée.
• Créer 2 constructeurs.
• Créer les getters et les setters
• Créer la méthode toString
• Créer la classe Cercle qui hérite de Forme
• Créer les méthodes périmètre() et surface()
• Créer la classe Carre qui hérite de Forme
• Créer les méthodes périmètre() et surface()
• Dans un tableau, instanciez des formes, des cercles et des carrés, puis
boucler pour appeler la méthode surface().
CHAPITRE 3 57
 Classes abstraites
Une classe abstraite est une classe incomplète. Elle regroupe un ensemble d’attributs
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.

A quoi ça sert ?
En général à définir les grandes lignes du comportement d'une classe d'objets
sans forcer l'implémentation des détails de l'algorithme

En java, c'est le mot clef abstract qui permet de qualifier d'abstraite une classe ou
une méthode

CHAPITRE 3 58
 Classes abstraites

Pourquoi "abstraite" ?
Une classe est abstraite soit parce qu'on n'est pas capable d'écrire
l'implémentation de toutes les méthodes, soit parce qu'on ne veut pas créer
d'instance de cette classe.

Une sous-classe qui n'implémente pas toutes les méthodes abstraites de sa

super-classe est elle-même abstraite. Il faut donc la qualifier d'abstraite.

Quand on ne peut pas écrire d'implémentation pour une méthode donnée,

cette méthode est qualifiée d'abstraite. Cela signifie que l'on laisse le soin aux sous-
classes d'implémenter cette méthode.
CHAPITRE 3 59
 Classes abstraites
• Une classe abstraite ne peut pas être instanciée. Il peut être sous-
classé (étendu) tant que la sous-classe est soit abstraite, soit
implémente toutes les méthodes marquées comme abstraites par les
super-classes.
• Le recours aux classes abstraites facilite la conception orientée
objet
• On peut placer dans une classe abstraite toutes les fonctionnalités
dont on souhaite disposer pour toutes ses descendances
CHAPITRE 3 60