Langage Oriente Objet Cours 3.

Présentation au sujet: "Langage Oriente Objet Cours 3."— Transcription de la présentation:

1 Langage Oriente Objet Cours 3

2 Référence (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

3 Référence (2) Il existe deux types de variables :
les variables de type primitif 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 Y Z X 12

4 Passage des paramètres
Le mode de passage des paramètres dans les méthodes dépend de la nature des paramètres : par référence pour les objets 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

5 Passage par référence et constructeur par 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 ; }

6 Passage par référence et constructeur par recopie (2)
Ce qu’il ne faut pas faire : class A { int x ; … } class B { A a; … B(B b) { a = b.a; } }

7 Passage par référence et constructeur par recopie(3)
B o1 = new B(); o1 B B o2 = new B(o1); B o2 A x=0 x=1 O2.a.x = 1;

8 Passage par référence et constructeur par 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); } }

9 Destruction d'un objet (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.

10 Destruction d'un objet (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 instance c1 = 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.

11 this Le mot clé this réfère l’objet lui-même.
Deux utilisations fréquentes : 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; } …} passer en paramètre la référence de l’objet lui-même. class A {… void m1(A a) {…} void m2(…) {… m1(this) ; …} }

12 Les packages (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)

13 Les packages (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.

14 Les packages (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 package 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, ...)

15 Les packages (4) CLASSPATH = $JAVA_HOME/lib/classes.zip;$HOME/classes
graph/2D/Circle.java package graph.2D; public class Circle() { ... } graph/3D/Sphere.java package 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 }

16 Accessibilité (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

17 Accessibilité (2) package p1; import p1.*; public class A {
public A(…) {…} void f(…) {…} } class B { A a=new A(); B(…) {…} void f(…) { a.f(); } import p1.*; class Program { public static void main(…){ A a=new A(…); B b=new B(…); … a.f() ; }

18 Accessibilité (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. Program.java A.java class Program { static void main(…) { A a=new A(); a.f(); } class A { A(…) {…} void f(…) {…} }

19 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

20 Static 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

21 Exemple de classe public 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

22 Partie 5 L’héritage

23 L’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

24 L'héritage - Exemple Polygone Spécialisation Généralisation
Quadrilatère Parallélogramme Trapèze Triangle Rectangle Losange Carré

25 Hé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.

26 Hé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.

27 Héritage class Art { Art() { System.out.println("Art constructor"); }
Constructeur sans paramètre 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();

28 Hé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

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

30 Héritage Lorsqu’une méthode est réécrite dans une sous-classe, on parle de surcharge Par exemple : si on définit un Polygone avec un tableau de points, pour le dessiner il suffit de faire un tracé entre chaque point 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 => on surcharge la méthode dessiner en la spécialisant avec les propriétés spécifique du carré

31 Héritage public class Detergent extends Cleanser { class 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(); 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(); } 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.

32 Hé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)); // false System.out.println((e instanceOf Ellipse)); // true System.out.println((c instanceOf Circle)); // true System.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)); // true System.out.println((e instanceOf Ellipse)); // true int r = e.getRadius(); // Error: method getRadius not found in class Ellipse c = e; // Error: Incompatible type for =. Explicit cast needed // (une ellipse n’est pas forcément un cercle !)

33 Le 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

34 Le masquage des variables
class A { int x; void m() { ... } } class B extends A{ class C extends B { int x, a ; void test() { a = super.x ; // a reçoit la valeur de la variable x de la classe B a = super.super.x ; // Syntax error a = ((B)this).x ; // a reçoit la valeur de la variable x de la classe B a = ((A)this).x ; // a reçoit la valeur de la variable x de la classe A super.m() ; // Appel à la méthode m de la classe B super.super.m() ; // Syntax error ((B)this).m() ; // Appel à la méthode m de la classe C (et non B) ! }}

35 L'encapsulation des membres
class c1 { public int A; protected int B; int C; private int D; } Package P1 Package P2 class c4 extends c1 { ... } class c2 extends c1 { ... } class c3 { ... } class c5 { ... } A B C D Accessible par c2 o o o - Accessible par c3 o o o - Accessible par c4 o o - - Accessible par c5 o - - -