Programmation Orientée Objet
JAVA
Chapitre N°4
Concepts orientés objets
Héritage
[email protected]
Classes et Héritage
Héritage
Relation entre deux classes parent et enfant.
Les enfants héritent les propriétés du parent.
Classe enfant (sous-classe) possède systématiquement les
attributs et les méthodes de la classe parent (super-classe)
Héritage simple (une seule super-classe pas plus)
Principe
Définir les propriétés communes dans la classe supérieure.
Définir les propriétés spécifiques dans la sous-classe.
Regrouper les objets le plus possible.
Les objets d’une sous-classe sont aussi des objets de la super-classe.
La classe dont tous les objets appartiennent: Object
Tester l’appartenance d’un objet à une classe: utiliser instanceof qui retourne
boolean
(exemple obj instanceof Etudiant )
Classes et Héritage
Exemple.
class Personne {
String nom;
int anneeNaissance;
public int age(int annee)
{
return annee - anneeNaissance; }
}
class Etudiant extends Personne { Personne
String [] cours;
String niveau; Professeur Etudiant
String ecole;
…
} Permanant Vacataire
Ce qui est disponible dans Etudiant:
nom, anneeNaissance, age(int ),
cours, niveau, ecole, …
Exemple
public class Ellipse {
public double r1, r2;
public Ellipse(double r1, double r2) { this.r1 = r1; this.r2 = r2; }
public double area() {return Math.PI * r1 * r2;}
}
final class Cercle extends Ellipse { super(r,r): constructeur de la
public Cercle(double r) {super(r, r);} super-classe
public double getRadius() {return r1;}
}
// Dans une méthode final assure qu’aucune autre
Ellipse e = new Ellipse(2.0, 4.0); classe n’héritera de Cercle
Cercle c = new Cercle(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 Cercle)); // true
System.out.println((c instanceof Ellipse)); // true (car Cercle dérive de Ellipse)
e = c;
System.out.println((e instanceof Cercle)); // true
System.out.println((e instanceof Ellipse)); // true
int r = e.getRadius(); // erreur: méthode getRadius n’est pas trouvée dans la
classe Ellipse
c = e; // erreur: type incompatible pour = Doit utiliser un cast explicite
Casting
La classe de la référence détermine ce qui est disponible (à priori)
Exemple.
class A {
public void meth() {
System.out.println("Salut");
}
}
class B extends A {
int var;
}
A a = new A();
B b = new B();
a.meth(); // OK
b.meth(); // OK, héritée
b.var = 1; // OK
a.var = 2; // erreur
b= a; // erreur
a = b; // OK
a.var = 2; // erreur: var n’est à priori pas disponible pour une classe A
((B) a).var = 2; // OK, casting
Casting: transforme une référence d’une super-classe à celle d’une sous-classe.
Condition: l’objet référé est bien de la sous-classe.
Surcharge de méthode
class A
{
public void M1( ) {System.out.println("M1 de A"); }
}
class B extends A
{
public void M1(String nom)
{
System.out.println("Salut : M1 de B");
}
public void M1(String[ ] name)
{
System.out.println("Salut : M1 de B");
}
}
Dans la sous-classe: une version additionnelle
Signature de méthode: nom+type de paramètres
Surcharge: créer une méthode ayant une autre signature.
Overriding: écrasement
Par défaut, une méthode est héritée par une sous-classe.
Mais on peut redéfinir la méthode dans la sous-classe (avec la même
signature)
Les objets de la sous-classe ne possèdent que la nouvelle version de la
méthode.
Exemple :
class A {
public void meth() {System.out.println("Salut");}
}
class B extends A {
public void meth() {System.out.println("Hello");}
}
A a = new A();
B b = new B();
a.meth(); // Salut
b.meth(); // Hello
a = b; // a réfère à un objet de classe B
a.meth(); // Hello. Même si la référence est de classe A, l’objet est de classe B
Classe abstraite
Certains éléments peuvent être manquants dans une
classe, ou la classe peut être trop abstraite pour
correspondre à un objet concret.
Classe abstraite
Une classe non complétée ou une classe
conceptuellement trop abstraite.
Classe Shape
on ne connaît pas la forme exacte, donc
impossible de créer un objet
cependant, on peut savoir que chaque Shape
peut être dessinée.
abstract class Shape {
abstract void draw();
}
Interface
Interface
Un ensemble de méthodes sans Body (comportements)
exigées.
Une classe peut se déclarer conforme à (implanter) une
interface: dans ce cas, elle doit implanter toutes les
méthodes exigées.
Exemple :
public interface Inter {
public int carre(int a);
public void imprimer();
}
class X implements Inter {
public int carre(int a) { return a*a; }
public void imprimer() {System.out.println("des
informations"); }
}
Exemple
abstract class Shape { public abstract double perimeter(); }
interface Drawable { public void draw(); }
class Cercle extends Shape implements Drawable, Serializable {
public double r;
public Cercle(double r) { this.r=r;}
public double perimeter() { return 2 * Math.PI * r ; }
public void draw() {System.out.println(“Cercle déssiné”);}
}
class Rectangle extends Shape implements Drawable, Serializable {
public double height, width;
public Rectangle(double height ,double width)
{ this.height = height; this. width = width; }
public double perimeter() { return 2 * (height + width); }
public void draw() {System.out.println(“Rectangle déssiné”);}
}
...
Drawable[] drawables = {new Cercle(2), new Rectangle(2,3),
new Cercle(5)};
for(int i=0; i<drawables.length; i++)
drawables[i].draw();
Package
On organise les classes et les outils selon leurs
fonctionnalités et les objets qu’elles manipulent.
Les classes qui traitent les mêmes objets: package
Exemple:
Les classes pour traiter l’interface graphique sont dans le
package java.awt
Organisation des packages :
Hiérarchie
java.awt java javax
java.awt.event
javax.swing awt swing
…
event
classes
classes
Utiliser les packages existants
Au début d’un fichier, importer les classes
d’un package.
import java.awt.*;
Importer toutes les classes du package java.awt
(reliées aux fenêtres).
import java.awt.event.*;
Importer toutes les classes du package
java.awt.event (reliées au traitement
d’événements).
