Langage Oriente Langage Oriente Objet Objet

Cours 3Cours 3

RéférenceRéférence (1)(1)• Pour manipuler un objet déjà créé, on déclare une référence

sur la classe de cet objet :

Circle c ;

• Une référence peut ne référencer aucun objet -> elle référence alors l’objet null

2

RéférenceRéférence (2)(2)• Il existe deux types de variables :

o les variables de type primitifo les variables de type « objet »

• Dans le premier, les variables sont des zones de stockage de la valeur associée à la variable (ex : x=12)

• Dans le deuxième, les variables sont des références (« pointeurs ») sur des zones de stockage

3

X12

Y

Z

Passage des Passage des paramètresparamètres

• Le mode de passage des paramètres dans les méthodes dépend de la nature des paramètres :o par référence pour les objetso par copie pour les types primitifs

public class C {

void methode1(int i, StringBuffer s) { i++; s.append("d");}

void methode2() { int a= 0; StringBuffer str = new StringBuffer("abc");

methode1(a, str); System.out.println(a=" + a + ", str=" + str); // a=0, str=abcd

}

} 4

Passage par référence et constructeur par Passage par référence et constructeur par recopie (1)recopie (1)

• Le constructeur par recopie créée une instance à partir de la définition d'une instance de la même classe.

Circle(Circle p_circle) {x = p_circle. x ; y = p_circle. y ;rayon = p_circle. rayon ;

}

5

Passage par référence et constructeur par Passage par référence et constructeur par

recopie (2)recopie (2)

• Ce qu’il ne faut pas faire :

class A { int x ; … }

class B { A a; … B(B b) { a = b.a; } …}

6

Passage par référence et constructeur par Passage par référence et constructeur par

recopie(3)recopie(3)

7

Ax=0

Bo1

B o1 = new B();

B o2 = new B(o1);

o2 B

O2.a.x = 1; x=1

Passage par référence et constructeur par Passage par référence et constructeur par

recopie (4)recopie (4)

• Si la classe possède un attribut de type classe alors il faut réaliser une copie de cet attribut.

class A { int x ; … }

class B { A m_a; … B(B p_b) { m_a = new A(p_b.m_a); } …}

8

Destruction d'un objet Destruction d'un objet (1)(1)

• La destruction des objets est prise en charge par le garbage collector (GC).

• Le GC détruit les objets pour lesquels il n'existe plus de référence.

• Les destructions sont asynchrones (le GC est géré dans un thread de basse priorité).

• Aucune garantie n'est apportée quant à la destruction d'un objet.

• Si l'objet possède la méthode finalize, celle-ci est appelée lorsque l'objet est détruit.

9

Destruction d'un objet Destruction d'un objet (2)(2)

class Circle {...void finalize() { System.out.println("Je suis garbage collecte"); }

}...

Circle c1;if (condition) {

Circle c2 = new Circle(); // c2 référence une nouvelle instancec1 = c2;

} // La référence c2 n'est plus valide mais il reste une référence,c1,// sur l'instance

c1=null; // L'instance ne possède plus de référence. Elle n'est plus // accessible. A tout moment le GC peut détruire l'objet.

10

thisthis• Le mot clé this réfère l’objet lui-même.• Deux utilisations fréquentes :

o les noms des paramètres d’une méthode membre sont les mêmes que les attributs de la classe, this permet de lever l’ambiguïté.

class A {int a; …void m1(int a) { this.a=a; }

…}

o passer en paramètre la référence de l’objet lui-même.class A {…

void m1(A a) {…}void m2(…) {… m1(this) ; …}

}

11

Les packagesLes packages (1)(1)• Un package regroupe un ensemble de classes sous un même

espace de 'nommage'.

• Le mot clé package indique à quel package appartient la ou les classe(s) de l'unité de compilation (le fichier).

• package doit être la première instruction du fichier.

• Les noms des packages suivent le schéma : name.subname … (ex. java.util)

• Une classe Watch appartenant au package time.clock doit se trouver dans le fichier time/clock/Watch.class (time et clock étant des répertoires)

12

Les packagesLes packages (2)(2)• Seules les classes publiques sont accessibles (instanciables) à l’extérieure du

package• toutes les autres classes sont utilisables seulement à l’intérieur du package.

package graph.2D;public class Cercle {…}class Rayon {…}

• Les packages permettent au compilateur et à la JVM de localiser les fichier contenant les classes à charger.

13

Les packagesLes packages (3)(3)• Les répertoires contenant les packages doivent être présents dans

la variable d'environnement CLASSPATH• En dehors du package, les noms des classes sont :

packageName.className

Par exemple, java.util.Vector v=new Vector();

• L'instruction import packageName permet d'utiliser des classes sans les préfixer par leur nom de packageo Ex : import java.util.* (toutes les classes du package java.util peuvent

être utilisées sans mentionner le nom du package comme indiqué au point précédent)

• Les APIs sont organisées en package (java.lang, java.io, ...)

14

Les packagesLes packages (4)(4)

15

graph/2D/Circle.javapackage graph.2D;public class Circle(){ ... }

graph/3D/Sphere.javapackage graph.3D;public class Sphere(){ ... }

paintShop/MainClass.java__________________________________package paintShop;

import graph.2D.*;

public class MainClass(){ public static void main(String[] args) { graph.2D.Circle c1 = new graph.2D.Circle(50) Circle c2 = new Circle(70); graph.3D.Sphere s1 = new graph.3D.Sphere(100); Sphere s2 = new Sphere(40); // error: class paintShop.Sphere not found}

CLASSPATH = $JAVA_HOME/lib/classes.zip;$HOME/classes

AccessibilitéAccessibilité (1)(1)• L'accessibilité des membres (attributs ou méthodes) est

pondérée par des critères de visibilité : public, private, protected et friendly

• friendly (par défaut) : les classes appartenant au même package peuvent y accéder ; aucun mot clé n’est spécifié devant le membre

• public : le membre est accessible par tout le monde

• private : personne ne peut accéder au membre excepté l’objet lui-même

• protected : seules les membres de sous-classes peuvent accéder

16

AccessibilitéAccessibilité (2)(2)

17

package p1;

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

class B { A a=new A();

B(…) {…} void f(…) { a.f(); }}

AccessibilitéAccessibilité (3)(3)• Si l’unité de compilation se compose d’un package (pas de

déclaration de package en début de fichier) alors tout membre sans qualificatif d’accès est public pour toute classe définie dans le même répertoire.

18

class A {A(…) {…}void f(…) {…}

}

A.javaclass Program {

static void main(…) { A a=new A();

a.f();}

}

Program.java

Accès privéAccès privé

• L’accès privé est vivement recommandée

• Cette approche permet de contrôler les accès aux différents membres et surtout d’offrir une interface fonctionnelle indépendante de l’implémentation

• L’accès en lecture et/ou en écriture des membres se fait alors par l’intermédiaire de méthodes du type getXxx() et setXxx() dont les paramètres sont de préférence de type primitif

19

StaticStatic• Les variables static sont communes à toutes les

instances de la classe.

• Les méthodes static sont des méthodes de classe, il n'est pas nécessaire d'instancier une classe pour appeler un de ses membres statiques.

• Les méthodes statiques ne peuvent pas accéder à this

20

Exemple de classeExemple de classepublic class Circle {

public static int count = 0;public static final double PI = 3.14; // final pour éviter Circle.PI = 4;public double x, y, r;

public Circle(double r) { this.r = r; count++;)

public Circle bigger(Circle c) {if (c.r > r) return c; else return this;

}

public static Circle bigger(Circle c1, Circle c2) {if (c1.r > c2.r) return c1; else return c2;

}

public static void main (String[] args){Circle c1 = new Circle(10); Circle c2 = new Circle(20);n = Circle.count; // n = 2;Circle c3 = c1.bigger(c2); // c3 = c2;Circle c4 = Circle.bigger(c1, c2); // c4 = c2

}} 21

Partie 5Partie 5

22

L ’héritage

L’héritageL’héritage• L’héritage est la technique la plus utilisée pour

réaliser la généralisation ou la spécialisation

• Construire une classe à partir d’une ou plusieurs autres classes, en partageant des attributs, des opérations et parfois des contraintes, au sein d'une hiérarchie de classes

• Chaque sous-classe incorpore, ou hérite, toutes les propriétés de sa super-classe et y ajoute ses propres et propriétés

23

L'héritage - ExempleL'héritage - Exemple

24

Rectangle

Carré

TriangleParallélogramme

Losange

Polygone

Trapèze

QuadrilatèreGénéralisationSpécialisation

HéritageHéritage

• Une classe ne peut hériter (extends) que d'une seule classe.

class nom_classe extends nom_classe_mère {… }

• Pas d’héritage multiple

• Les classes de base de Java dérivent, par défaut, de java.lang.Object

• Le mot clé super désigne la classe mère

• L'opérateur instanceOf permet de déterminer la classe d'une instance

• Les classes final ne peuvent pas être redéfinies dans les sous-classes.

25

HéritageHéritage

• L’initialisation des objets passe par l’appel à un constructeur

• Dans une sous-classe, le constructeur de cette classe doit faire appel à un constructeur de la classe mère pour que l’initialisation soit correcte.

• Par défaut, Java fait appel au constructeur sans paramètre.

26

27

class Art { Art() { System.out.println("Art constructor"); }} class Drawing extends Art {

Drawing() { System.out.println("Drawing constructor"); }}

public class Cartoon extends Drawing { Cartoon() { System.out.println("Cartoon constructor"); } public static void main(String[] args) { Cartoon x = new Cartoon(); }}

Constructeur sans paramètreConstructeur sans paramètre

HéritageHéritage

• Dans le cas du constructeur sans paramètre, le compilateur n’a pas de problème pour savoir quel constructeur de la classe mère appeler puisqu’il n’en existe qu’un seul

• Si le constructeur a des paramètres, il faut explicitement indiquer quel constructeur appeler

28

HéritageHéritage

29

class Game { Game(int i) { System.out.println("Game constructor") ; }}

public class Chess extends BoardGame { Chess() { super(11); System.out.println("Chess constructor"); } public static void main(String[] args) { Chess x = new Chess() ; }}

class BoardGame extends Game { BoardGame(int i) { super(i) ; System.out.println("BoardGame

constructor") ; }}

HéritageHéritage

• Lorsqu’une méthode est réécrite dans une sous-classe, on parle de surcharge

• Par exemple :o si on définit un Polygone avec un tableau de points, pour le

dessiner il suffit de faire un tracé entre chaque pointo si on définit ensuite la classe Carre comme une sous-classe de

polygone, on peut redéfinir la méthode dessiner car l’algorithme peut être plus efficace

o => on surcharge la méthode dessiner en la spécialisant avec les propriétés spécifique du carré

30

HéritageHéritage

31

class Cleanser {

private String s = new String("Cleanser"); public void append(String a) { s += a; } public void dilute() { append(" dilute()"); } public void apply() { append(" apply()"); } public void scrub() { append(" scrub()"); } public void print() { System.out.println(s);} public static void main(String[] args) { Cleanser x = new Cleanser(); x.dilute(); x.apply(); x.scrub(); x.print(); }

}

public class Detergent extends Cleanser { public void scrub() { append(" Detergent.scrub()"); super.scrub(); }

public void foam() { append(" foam()"); }

public static void main(String[] args) { Detergent x = new Detergent(); x.dilute(); x.apply(); x.scrub(); x.foam(); x.print(); }}

Les méthodes dilute, apply, print sont des méthodes héritées. La méthode scrub est redéfinie. La méthode foam est une nouvelle méthode.

Les méthodes dilute, apply, print sont des méthodes héritées. La méthode scrub est redéfinie. La méthode foam est une nouvelle méthode.

HéritageHéritage

public class Ellipse {protected double r1, r2;public Ellipse(double r1, double r2) { this.r1 = r1; this.r2 = r2 ; }public double area() { ... }

}final class Circle extends Ellipse {

public Circle(double r) { super(r, r) ; }public double getRadius() { return r1 ; }

}------------------------------------------------------------------------------------------------------------------

---Ellipse e = new Ellipse(2.0, 4.0);Circle c = new Circle(2.0);System.out.println("Aire de e : " + e.area() + ", Aire de c:" + c.area());System.out.println((e instanceOf Circle)); // falseSystem.out.println((e instanceOf Ellipse)); // trueSystem.out.println((c instanceOf Circle)); // trueSystem.out.println((c instanceOf Ellipse)); // true (car Circle dérive de Ellispe)

e = c; // OK (avec extends : un Circle est une Ellipse)System.out.println((e instanceOf Circle)); // trueSystem.out.println((e instanceOf Ellipse)); // trueint r = e.getRadius(); // Error: method getRadius not found in class Ellipsec = e; // Error: Incompatible type for =. Explicit cast needed

// (une ellipse n’est pas forcément un cercle !)32

HéritageHéritage

Le masquage des variablesLe masquage des variables

• Une classe peut définir des variables portant le même nom que celles de ses classes ancêtres.

• Une classe peut accéder aux attributs redéfinis de sa classe mère en utilisant super ou par cast

• Une classe peut accéder aux méthodes redéfinies de sa classe mère en utilisant super

33

Le masquage des variablesLe masquage des variablesclass A {

int x;void m() { ... }

}

class B extends A{int x;void m() { ... }

}

class C extends B {int x, a ;void m() { ... }void test() {

a = super.x ; // a reçoit la valeur de la variable x de la classe Ba = super.super.x ; // Syntax errora = ((B)this).x ; // a reçoit la valeur de la variable x de la classe Ba = ((A)this).x ; // a reçoit la valeur de la variable x de la classe Asuper.m() ; // Appel à la méthode m de la classe Bsuper.super.m() ; // Syntax error((B)this).m() ; // Appel à la méthode m de la classe C (et non B) !

}}

34

L'encapsulation des membresL'encapsulation des membres

35

class c1 { public int A; protected int B; int C; private int D;}

class c3 { ...}

class c5 { ...}

A B C DAccessible par c2 o o o -Accessible par c3 o o o -Accessible par c4 o o - -Accessible par c5 o - - -

Package P1 Package P2

class c4 extends c1 { ...}

class c2 extends c1 { ...}