L`héritage (1) L`héritage (2) Le masquage des variables (1) Le

Le langage Java B. Djafri (46)
L’héritage (1)
♦Une classe ne peut hériter (extends) que d'une seule classe
(héritage simple).
♦Toute classe dérive, par défaut, de java.lang.Object
♦Une référence d'une classe C peut contenir des instances de C
ou des classes dérivées de C.
♦L'opérateur instanceof permet de déterminer la classe d'une
instance.
♦Les classes final ne peuvent pas être redéfinies dans des
sous-classes (ne peut pas être héritée).
♦Les méthodes final ne peuvent pas être redéfinies.
Le langage Java B. Djafri (47)
L’héritage (2)
public class Ellipse {
public 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;
System.out.println((e instanceof Circle)); // true
System.out.println((e instanceof Ellipse)); // true
double r = e.getRadius(); // Error: method getRadius not found in class Ellipse.
c = e; // Error: Incompatible type for =. Explicit cast needed.
Le langage Java B. Djafri (48)
Le masquage des variables (1)
♦Une classe peut définir des variables portant le même
nom que celles de ses classes ancêtres (super classes).
♦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.
♦Les constructeurs ne sont pas hérités (≠méthodes)
Le langage Java B. Djafri (49)
Le masquage des variables (2)
class A {
int x;
void m() {...}
}
class B extends A{
float x;
void m() {...}
}
class C extends B {
double x, a;
void m() {...}
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 de la méthode m de la classe B
super.super.m(); // Syntax error
((B)this).m(); // Appel de la méthode m de la classe C (et non B)
}
}

Le langage Java B. Djafri (50)
L’encapsulation
class c1 {
public int A;
protected int B;
int C;
private int D;
}
class c3 {
...
}
class c5 {
...
}
ABCD
Accessible 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 {
...
}
Le langage Java B. Djafri (51)
Structure des classes (suite)
♦Le mot clé class peut-être précédé de l'un des trois
mots clé : public, abstract et final
•public : la classe peut-être utilisée par n'importe quelle
autre classe.
•final : aucune classe ne peut hériter d'elle.
•abstract : la classe ne peut pas être instanciée.
•Par défaut, une classe ne peut-être utilisée que par les
classes appartenant au même package.
Le langage Java B. Djafri (52)
Copies d’objets (1)
♦La copie des objets ≠copies des références
♦Utilisation de la méthode particulière clone()
♦La méthode clone() est héritée de java.lang.Object
♦Le transtypage est nécessaire pour l’utilisation de la méthode
clone() (retourne un Object)
♦Tous les objets ne peuvent êtres clonés (implémentation de
l’interface Cloneable)
♦clone() crée un copie superficielle (les références membres
sont copiées et non clonées)
♦La méthode clone() peut être redéfinie
Le langage Java B. Djafri (53)
Copies d’objets (2)
Point p1 = new Point(3.5, 7.1);
Point p2 = p1; // référence le même objet
Point p3 = (Point)p1.clone(); // Attention !
p3.x = 11.5;
int[] T = {1, 2, 3};
int[] copy = (int[])T.clone(); // une copie du tableau
Point[][] tPoints =
{ {new Point()}, {new Point(), new Point(3., 5.)} };
Point[][] copy = (Point[][]) tPoints.clone();
// copie les deux références uniquement

Le langage Java B. Djafri (54)
Comparaison d’objets (1)
♦L’opérateur de comparaison (==) compare des
références et des valeurs primitives.
♦Deux types d’égalité
•Égalité de références
•Égalité des objets (objets équivalents, même contenu)
♦La méthode equals() teste l’équivalence de deux
objets
♦Tous les objets héritent la méthode equals()
♦L’implémentation par défaut est : ==
Le langage Java B. Djafri (55)
Comparaison d’objets (2)
String message = "Hello!" ;
String s = "Hello!" ;
if(message == s) ...
// les 2 références sont différentes
int[] T = {1, 2, 3};
int[] A = (int[])T.clone();
if(T == A) ...
// même contenu, mais pas égaux (équivalents)
if(message.equals(s))... // il y a égalité
Le langage Java B. Djafri (56)
Conversion de type
♦Java n’autorise aucune conversion entre types primitifs
et types références
♦Java autorise certaines conversions entre certains types
références
•Types appartenant à la même hiérarchie (hiérarchie de
classes)
•int, double, … en String : la méthode toString() héritée de
java.lang.Object
♦Les tableaux n’ont pas de hiérarchie de types (classes)
Le langage Java B. Djafri (57)
Destruction d’objets (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
(processus léger de basse priorité).
♦Aucune garantie n'est apportée quant à la destruction d'un objet.
♦La méthode finalize()est appelée lorsque l'objet est détruit.
♦Chaque classe possède une méthode finalize(), qui peut être
redéfinie.

Le langage Java B. Djafri (58)
Destruction d’objets (2)
public class Point {
...
protected void finalize(){
System.out.println("destruction de l’objet"+ this); }
}
{...
Point p1;
if (condition) {
Point p2 = new Point(); // p2 référence une nouvelle instance de Point
p1 = p2; // p1 et p2 référencent la même instance de la classe Point
}
// La référence p2 n'est plus valide, mais il reste une référence p1
// sur l'instance
p1=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.
Le langage Java B. Djafri (59)
Les classes abstraites (1)
♦Une méthode abstraite ne possède pas de définition (corps).
♦Une classe contenant une méthode abstraite est une classe abstraite et
doit être déclarée abstraite (abstract).
♦Une classe abstraite est précédée du mot clé abstract
♦Une classe abstraite ne peut pas être instanciée (new), mais peut être
héritée (sous-classe concrète).
♦Une classe abstraite peut définir des méthodes abstraites (non static,
private, final).
♦Une classe dérivée d'une classe abstraite ne redéfinissant pas toutes les
méthodes abstraites est elle-même abstraite.
Le langage Java B. Djafri (60)
Les classes abstraites (2)
public abstract class Shape {
public abstract double perimeter();
}
public class Circle extends Shape {
...
public double perimeter() { return 2 * Math.PI * r ; }
}
public class Rectangle extends Shape {
...
public double perimeter() { return 2 * (height + width); }
}
...
Shape[] shapes = {new Circle(2), new Rectangle(2,3), new Circle(5)};
double sum_of_perimeters = 0;
for(int i=0; i<shapes.length; i++)
sum_of_perimeters += shapes[i].perimeter();
Le langage Java B. Djafri (61)
Les classes abstraites (3)
public abstract class Message {
private String sender;
public Message(String from){ sender = from; }
public abstract void play();
public String getSender(){ return sender; }
}
public class TextMessage extends Message {
private String text;
public TextMessage(String from, String t){
super(from); text = t;
}
public void play(){
System.out.println(text);
}
}
public class VoiceMessage extends Message {
...
}

Le langage Java B. Djafri (62)
Les interfaces (1)
♦Une interface correspond à une classe abstraite où toutes les
méthodes sont abstraites (interface = type référence)
•Les méthodes sont déclarées implicitement abstraites et publiques
(même si les mots clés public et abstract sont omis).
•Que des méthodes d’instance ou des constantes (pas de
constructeurs, de variables d’instance, de méthodes statiques).
•Pas de détail, pas d’attributs (sauf des constantes static final)
♦Une classe peut implémenter (implements) une ou plusieurs
interfaces tout en héritant (extends) d'une classe (une seule).
♦Une interface peut hériter (extends) de plusieurs interfaces.
Le langage Java B. Djafri (63)
Les interfaces (2)
abstract class Shape { public abstract double perimeter(); }
interface Drawable { public void draw(); }
class Circle extends Shape implements Drawable {
...
public double perimeter() { return 2 * Math.PI * r ; }
public void draw() {...}
}
class Rectangle extends Shape implements Drawable, Serializable {
...
public double perimeter() { return 2 * (height + width); }
public void draw() {...}
}
...
Drawable[] drawables = {new Circle(2), new Rectangle(2,3), new
Circle(5)};
for(int i=0; i<drawables.length; i++)
drawables[i].draw();