Chapitre IV :

Relations entre classes en Java

A.Hammache 1
Plan du Chapitre

Relations entre classes

Composition

Héritage

Polymorphisme

Les classes abstraites

Les interfaces

Les packages

A.Hammache 2
 Relations entre classes

Moteur Voiture Personne

Etudiant Employé

30/08/2020 3
 Composition
 Un objet peut être composé à partir d’autres objets
1. Chaque objet composant est un attribut de l'objet composé.
2. Généralement, on fait appel au constructeur de l'objet composant dans le
constructeur de l'objet composé.

public class Voiture { class Moteur {

Moteur moteur; ……………………………………………
Roue roueAVG,roueAVD, roueARG,
void démarrer() {
roueARD , roueSecours ;
}
..............
}
public Voiture (){
class Roue {
moteur= new Moteur();
private float pression;
roueAVG = new Roue();
Pneu pneu;
roueAVD = new Roue();
roueARG = new Roue();
public Roue() {
roueARD = new Roue();
pneu = new Pneu();
......................
pression = 50;
}
}
}
}

30/08/2020 Hammache.A 4
 Héritage
 Héritage : mécanisme permettant à une classe (sous-classe) d’hériter
(réutiliser) et/ou de redéfinir les propriétés d’une autre classe
(superclasse). La relation d’héritage est une relation de généralisation
/ spécialisation.
Hom m e
A g e : In t e g e r
T a ille : D o u b le
P o id s : D o u b le
N o m : S t rin g Superclasse
p a rle ()
m a n g e ()
b o it ()
d o rt ()

Lien d’héritage
C o n d u c teu r

c o n d u ire ()
Sous-classe
d e m a rre r()

Représentation avec UML d’un héritage (simple)

30/08/2020 5
 Héritage
 Java implémente le mécanisme d'héritage simple
qui permet de "factoriser" de l'information grâce
à une relation de généralisation / spécialisation
entre deux classes.
 L'héritage multiple n'existe pas en Java.

 Pour le programmeur, il s'agit d'indiquer, dans la

sous-classe, le nom de la superclasse dont elle
hérite.
 Mot réservé : extends

 Par défaut toutes classes Java hérite de la classe

Object
30/08/2020 6
 Héritage
class A{

A //attributs A
Superclasse
//Méthodes A

}
Est un
class B exetends A{

B //attributs B
Sous-classe
//Méthodes B

30/08/2020 7
 Héritage

Personne
class Personne
nom : String
{ date_naissance : Date
private String nom;
private Date date_naissance;
// ...
}
Employe
class Employe extends Personne salaire : Double
{
private float salaire;
// ...
}

class Etudiant extends Personne Etudiant

{ numero_carte_etudiant : Integer

private int numero_carte_etudiant;

// ...
}
30/08/2020 8
 Héritage
Etapes de construction d’un objet dérivé
class Personne class TestPersonne {
{ public static void main(String[] args){
private String nom;
private Date date_naissance; Employe e1=new Employe(6000);
// ...
} }

class Employe extends Personne

{
private float salaire;
Public Employe(float s){
salaire=s;
}

// ...
}

30/08/2020 9
 Héritage
Pour forcer l'appel d'un constructeur précis, on utilisera le mot
réservé super. Cet appel devra être la première instruction du
constructeur

public class Personne

public class Employe extends Personne
{
{
private String nom, prenom;
public Employe () {}
private Date date_naissance;
public Employe (String nom,
public Personne()
Date date_naissance,
{
float salaire)
nom=""; …
{
}
super(nom, date_naissance);
public Personne(String nom,
…………
Date date_naissance)
…………
{
}
this.nom=nom;
}
this. date_naissance = date_naissance;
}
Appel explicite à ce constructeur }
avec le mot clé super
30/08/2020 10
 Redéfinition de méthodes
 Une sous-classe peut redéfinir des méthodes existantes dans une de ses
superclasses (directe ou indirectes), à des fins de spécialisation.
– Le terme anglophone est "overriding". On parle aussi de masquage.
– La méthode redéfinie doit avoir la même signature.
– L’utilisation du final class Employe extends Personne
{
Personne private float salaire;
public float calculePrime( )
{
// ...
redéfinition
}
}
Etudiant Employe
class Cadre extends Employe
calculePrime() {
public float calculePrime()
{
Cadre // ...
}
// ...
30/08/2020
calculePrime() 11
}
 Référence à la superclasse
 Le mot réservé super permet de faire référence au constructeur
de la superclasse directe mais aussi à d’autres informations
provenant de cette superclasse.

class Employe extends

Personne Appel à la méthode calculPrime()
{ de la superclasse de Cadre
private float salaire;
public float calculePrime() class Cadre extends Employe
{ {
return (salaire * 0,05); public float calculePrime()
} {
// ... return (super.calculePrime() * 2);
} }
// ...
}

30/08/2020 12
 Polymorphisme
 Types
– Statique
– Dynamique dit « d’héritage »
 Mise en œuvre
1. Références de type super classe
2. Recherche dynamique de méthode:
déclenchement de la méthode la plus spécifique
d’un objet, c'est-à-dire celle correspondant au
type réel de l'objet, déterminé à l'exécution
uniquement (et non le type de la référence, seul
type connu à la compilation, qui peut être plus
générique).
30/08/2020 13
 Polymorphisme

Employe ahmed= new Employe();

ahmed.calculePrime();

Employe
salaire : Double

calculePrime()

Employe ahmed= new Cadre();

Cadre
ahmed.calculePrime();

calculePrime()

30/08/2020 14
 Classes abstraites
 Il peut être nécessaire au programmeur de créer une
classe déclarant une méthode sans la définir (c'est-à-
dire sans en donner le code). La définition du code est
dans ce cas est laissée aux sous-classes.
 Une telle classe est appelée classe abstraite.
 Elle doit être notée avec le mot réservé abstract.
 Toutes les méthodes de cette classe qui ne sont pas
définies doivent elles aussi être marquées par le mot
réservé abstract.
 Une classe abstraite ne peut pas être instanciée.
 Impossible de faire new ClassAbstraite(...)

30/08/2020 15
 Classes abstraites
public abstract class Forme {
protected double x, y;
Forme public void deplacer(double dx, double dy) {
<<abstract>> x += dx; y+= dy;
}
perimetre() public abstract double perimetre();
surface() public abstract double surface();
}
public class Rectangle extends Forme {
Rectangle Cercle private hauteur;
hauteur rayon private largeur;
largeur perimetre() public double perimetre()
perimetre() surface() {
surface() return 2*(hauteur+largeur);
}
public double surface(){
Return (hauteur*largeur);
30/08/2020 } 16
 Les Interfaces
 Une interface définit un ou plusieurs services offerts
 Elle est composée d’un ensemble de méthodes abstraites et de
constantes (« static » et « final »)
 Une classe peut implémenter une ou plusieurs interfaces
 Elle doit fournir une implémentation pour chaque méthode

public interface A{
Interface A
Interface //attributs (constantes)
//Méthodes abstraites
}
implements
class B implements A{
Classe B //attributs de B
Classe //Méthodes
}
30/08/2020 17
 Les Interfaces
Comparable public interface Comparable{
<<interface>> public int estPlusGrand (Comparable other);
}
estPlusGrand()
class Rectangle implements Comparable {
implements private int largeur = 0; private int hauteur = 0;
public int getSurface() { return largeur *
Rectangle Employé hauteur; }

estPlusGrand() estPlusGrand() public int estPlusGrand(Comparable other) {

Rectangle autreRect = (Rectangle)other;
class Employé implements Comparable { if (this.getSurface() < autreRect.getSurface())
public int getAge() {……} return -1;
public int estPlusGrand(Comparable other) {
else if (this.getSurface() >
Employe autrePer = (Employe )other;
if (this.getSalaire() < autrePer.getSalaire())
autreRect.getSurface())
return -1; return 1;
else if (this.Salaire() > autrePer.getSalaire()) else
return 1; return 0;}}
else
return 0;}}
30/08/2020 18
 Héritage multiple d’interface
• Une interface peut hériter d’une ou plusieurs autres
interfaces
– Java supporte l’héritage multiple d’interface
• Une classe peut implémenter plusieurs interfaces
interface Affichable {
void afficher();}
interface Persistant {
void sauvegarder();}
interface SGBD extends Persistant {
void connecter();
}
class Point implements Affichable , SGBD {
private double x, y;
void afficher() {……};
void sauvegarder() {……};
void connecter() {……};
}

30/08/2020 19
 Interfaces et types
• Une interface définit un nouveau type
• Des objets différents peuvent répondre au même
message à condition qu’ils implémentent la même
interface
• L’opérateur « instanceof » peut être utilisé pour
savoir si un objet implémente une interface donnée
Affichable p1 = new Point();

if (p1 instanceof Affichable){

p1.afficher();
……
}

30/08/2020 20
 Quand utiliser les interfaces ?
• Pour définir des services techniques
• Pour contourner le fait que Java ne supporte pas
l’héritage multiple
• Interface vs Héritage :
– On utilise l’héritage quand un objet est un sous-type d’un
autre
– On utilise une interface pour décrire le fait qu’une classe
implémente un service particulier

Figure Comparable
extends
implements

Rectangle
30/08/2020 21
 Les packages
Un package est une bibliothèque de classes
On regroupe les classes d’un même domaine dans un
package
Meilleure réutilisation de code
Elimination des conflits de noms : ainsi vous pouvez
décrire deux classe qui porte le même nom mais qui
appartient à deux packages différents.
Apporte un niveau supplémentaire d’encapsulation.

30/08/2020 22
 Les packages

• Les classes du JDK sont classées dans des packages

java

lang util awt net

String.class Date.class event Button.class Socket.class

Thread.class Vector.class List.class URL.class
…

• Java importe automatiquement le package

« java.lang » qui contient des classes comme
« Thread » ou « System »
30/08/2020 23
 Les packages
• Le mot-clé « package » permet de définir un
nouveau package
• Utiliser le mot clé « import » pour importer
une classe ou un package
//fichier Compte.java dans le
finance //répertoire Finance
Compte package finance;
public class Compte {
…… }

//Fichier Client.java dans le

répertoire de l’application
achat package achat;
Client import finance.*;
public class Client {
Compte c = new Compte();
…… }
30/08/2020 24
 Règles de visibilité

public

protected

friendly
(par défaut)
private

30/08/2020 25