la réutilisation des classes1 sun services java programming language copyright 2005 k.allem all...

La réutilisation des classes 1

Sun Services

Java™ Programming Language

Copyright 2005 K.ALLEM All Rights Reserved


Sommaire

Introduction La composition L’héritage Le polymorphisme


Sommaire



Introduction Réutiliser [reytilize] v.tr. de re et utiliser.

Utiliser à nouveau ce qui a déjà servi. n.f réutilisationje réutiliserai ma classe existante

Réutiliser des classes existantes, est indispensable pour pouvoir développer de manière productive

La réutilisation s’exprime de plusieurs manières: la composition, l’héritage et le polymorphisme


Sommaire



La composition

Réutiliser en composant: une classe peut en référencer une autre classe

La composition associe un objet à un autre objet, définissant une relation « a un » entre ces deux objets


En UML… Agrégation et composition

Une agrégation est un cas particulier d’association non symétrique exprimant une relation de contenance

Une composition est une agrégation plus forte impliquant que: un élément ne peut appartenir qu’a un seul

agrégat composite La destruction de l’agrégat composite entraîne

la destruction de tous ses éléments (le composite est responsable du cycle de vie de parties)


La composition

Java

En Java, la réutilisationen composant s’exprime de cette façon:

private ClasseReutilisée champ;

UML

Composite Élément

Agrégat Élément1..* 0..*

0..*1


Exemple en UML

Personne

rue : StringcodePostal : Integerville : String

Adresse

nom : Stringprenom : Stringadresse : Adresse0..*11 0..*


Exemple en Javapublic class Adresse {

private String rue; private int codePostal; private String ville; … }

public class Personne{

private String nom; private String prenom; private Adresse adresse;

}


Sommaire



Réutiliser en héritant: une classe peut reprendre les caractéristiques d’une autre classe

L’héritage définit une relation « est un » entre deux classes, une sous classe héritant de sa super classe


Généralisation, super classe, sous classe Une super classe est une classe plus générale

reliée à une plusieurs ou plusieurs autres classes plus spécialisées (sous classes) par une relation de généralisation

Les sous classes « héritent » des propriétés de leur super classe et peuvent comporte des propriété spécifiques supplémentaires


Classe A1 Classe A2

Classe A


L’héritage Java

En Java, la réutilisation en héritant s’exprime de cette façon:

class SuperClasse{ //champs et méthodes}

class SousClasse extends SuperClasse{ //champs et méthodes supplémentaires}

UML

SuperClasse

SousClasse


On ne crée un lien d’héritage entre deux classes que si une instance de la sous classe peut être considéré aussi comme instance de sa super classe par la relation est un

la super classe ne se trouve pas nécessairement dans le même paquetage que la sous classe


exemple

Boisson

nom : Stringprix : Float

getNom() : StringgetPrix() : Float

BoissonAlcoolisee


Lors de la création d’un objet, la partie qui dépend de sa super classe est initialisée en premier, avant celle qui dépend de sa propre classe.

Si l’initialisation de la super classe requiert l’appel d’un constructeur avec paramètres, le passage des valeurs à ce constructeur s’effectue dans le constructeur de la classe dérivée avec comme première instruction

super(params);


exemple Les membres private d’une super classe restent

inaccessibles depuis ses sous classes Les membres freindly d’une super classe sont

accessibles depuis les sous classes qui appartiennent au même paquetage de la super classe

Les membres protected d’une super classe sont accessibles depuis n’importe quelle sous classe, quel que soit le paquetage de ces classes

Les membres public d’une super classe sont bien sûr accessibles depuis ses classes


Remarques L’héritage multiple n’existe pas en Java L’héritage multiple du C++ peut être

remplacé par la possibilité d’implémenter plusieurs interfaces dans une classe

Une classe n’hérite pas des constructeurs de sa super classe

On doit donc ajouter un constructeur à une classe si sa super classe n’a pas de constructeur sans paramètre


Le test « est un » Le test Est un une règle simple pour savoir

si 2 classes doivent être liées par une relation d’héritage : si A peut être liée à B, la phrase “A est un B” devrait avoir du sens. Par exemple :

un oiseau est un animalun chat est un mammifèreune tarte aux pommes est une tarteune fenêtre de texte est une fenêtreune sphère est un objet graphiqueun tableau d’entiers est un tableau


Par contre, les phrase suivantes sont inappropriées et donc l’héritage n’est pas approprié :

un oiseau est un mammifère

une tarte au pomme est une pommeun moteur est une voitureun tableau d’entiers est un entier


La relation d’héritage est transitive : les méthodes et les variables sont héritées à travers tous les niveaux (sans limitation du nombre de niveaux)


redéfinition de méthodes

Une méthode non private est redéfinie (overridden) quand elle est définie dans une sous classe avec le même identificateur, le même nombre de paramètre, et le même type pour chacun des paramètres


redéfinition de méthodes

Une sous-classe peut ajouter des variables et/ou des méthodes à celles qu’elle hérite de sa super-classe.

Une sous-classe peut redéfinir (override) les méthodes dont elle hérite et fournir ainsi des implémentations spécialisées pour celles-ci


Redéfinition d’une méthode Lorsque la classe définit une méthode

dont le nom, le type des paramètres et le type de retour sont strictement identiques à ceux d’une méthode dont elle hérite

nom + types paramètres + type retour = signature

Lorsqu’une méthode redéfinie par une classe est invoquée par un objet de cette classe, c’est la nouvelle définition et non pas celle de la superclasse qui est exécutée


Ne pas confondre redéfinition (overridding) avec surcharge (overloading)


Il faut faire attention à la signature des méthodes : deux signatures différentes définissent deux méthodes différentes, même si elles ont le même nom !


Exercice

Boisson

nom : Stringprix : Float

getNom() : StringgetPrix() : Float

BoissonAlcoolisee

degreAlcool : Integer

getDegreAlcool() : Integer


Sommaire



Réutiliser avec le polymorphisme: modifier l’implémentation des méthodes d’une autre classe

Le polymorphisme est rendu possible grâce à l’héritage (est un) et à la redéfinition des méthodes


Le polymorphisme est la faculté d’une classe à prendre plusieurs formes

Si une classe et ses sous classes implémentent différemment un même message, les objets des sous classes prennent des formes différentes pour ce message du point de vue de leur super classe


La possibilité de designer un objet d’une sous classe par une référence relevant de sa super classe est la traduction Java de la relation est unboisson = whisky;

boisson =(Boisson)whisky;c’est tellement logique que Java n’oblige pas à noter la classe de conversion!!


Relation « est un » et conversion de références Les conversions opérant sur une références

utilisent la syntaxe: reference1=(Classe)reference2;

Les conversions changent la classe d’une référence sans transformer ni la valeur de cette référence ni l’objet qu’elle désigne

Les conversions sont autorisées à la compilation si la classe de conversion et la classe de référence ont un lien d’héritage entre elles


Lors de l’exécution, la JVM vérifie que la classe de conversion est effectivement celle de l’objet référencé ou une super classe de cet objet


exempleclass ConversionsReferencesBoisson{ public static void main (java.lang.String [] args) { // Création d'objets Boisson eau = new Boisson ("Eau min\u00e9rale", 1f); BoissonAlcoolisee whisky = new BoissonAlcoolisee ("Whisky", 7.4f, 45); // Declaration d'autres références pour les tests Boisson boisson; BoissonAlcoolisee boissonForte; Boisson boissonInconnue = null;

Service service;


boisson = (Boisson)whisky;

// Compilation OK et exécution OK :// Conversion d'une référence d'une

classe vers sa super classe acceptée. Le whisky est une boisson


javax.swing.JOptionPane.showMessageDialog (null, boisson.getNom ());

// Avec la référence boisson, on peut appeler toutes les méthodes de la classe

// Boisson mais pas les méthodes supplémentaires de

// BoissonAlcoolisee, classe effective de l'objet designé

//affiche whisky


boissonForte = (BoissonAlcoolisee)boisson;

// Compilation OK et exécution OK :// Conversion d'une référence d'une classe vers

sa sous classe acceptée// a la compilation et a l'exécution, si l'objet

référence est effectivement// une instance de la sous classe. A l'exécution,

l'objet désigné par boisson// est bien un objet de classe BoissonAlcoolisee


boissonForte = (BoissonAlcoolisee)boissonInconnue;

// Compilation OK et exécution OK :// Conversion d'une référence d'une classe

vers sa sous classe acceptée// a la compilation et a l'exécution, si l'objet

référencé est inconnu.


boissonForte = (BoissonAlcoolisee)eau;

// Compilation OK mais exception java.lang.ClassCastException a l'execution :

// Conversion d'une référence d'une classe vers sa sous classe acceptee

// a la compilation mais refusee a l'execution, si l'objet referencé n'est pas

// effectivement une instance de la sous classe. A l'execution l'objet

// designé par eau n'est pas un objet de classe BoissonAlcoolisee, la JVM déclenche un exception qui interrompt le cours du programme


Intérêt Le polymorphisme offre :

Une plus grande simplicité du codePlus besoin de distinguer différents cas en fonction de la classe de l’objet


Et surtout une plus grande facilité d’évolution du code

Les programmes sont plus facilement extensibles car il est possible de définir de nouvelles fonctionnalités enhéritant de nouveaux types de données à partir d’uneclasse de base commune sans avoir besoin de modifier lecode qui manipule l’interface de la classe de base

En d’autres termes, vous pouvez écrire des programmescapables de travailler avec du code (classes) qui n’existent pas encore !


public class Adresse{ private String rue; // Champ memorisant la rue et son numero private int codePostal; // Champ memorisant le code postal private String ville; // Champ memorisant la ville d'une adresse

public Adresse (String rue, int codePostal, String ville) { this.rue = rue; this.codePostal = codePostal; this.ville = ville; }

public java.lang.String getRue() { return this.rue; }

public int getCodePostal() { return this.codePostal; }

public java.lang.String getVille() { return this.ville; }}


public class Personne{ private String nom; // Champ memorisant le nom d'une personne private String prenom; // Champ memorisant le prenom d'une personne private Adresse adresse; // Champ memorisant l'adresse d'une personne

public Personne (String nom, String prenom) { this.nom = nom; this.prenom = prenom; }

public String getNom() { return this.nom; }

public String getPrenom() { return this.prenom; }

/** * Modifie l'adresse de cette personne. */ public void setAdresse (Adresse adresse) { this.adresse = adresse; }

/** * Renvoie l'adresse de cette personne. */ public Adresse getAdresse() { return this.adresse; }}


class DeuxPersonnesUneAdresse{ public static void main (String[] args) { Personne personne1; // Creation d'une instance de Personne pour Thomas Durand personne1 = new Personne ("Durand", "Thomas"); Adresse adresse1; // Creation d'une instance de Adresse adresse1 = new Adresse("5, rue de Rennes", 7000, "MONS"); // Affectation de son adresse a Thomas personne1.setAdresse (adresse1);

// Creation d'une autre instance de Personne pour Sophie Martin Personne personne2 = new Personne("Martin", "Sophie"); // Affectation directe de l'autre adresse avec une nouvelle instance personne2.setAdresse(new Adresse("3, pl. de la Gare", 6000, "CHARLEROI"));

// Plus tard... Sophie demenage chez Thomas et partage donc son adresse personne2.setAdresse (personne1.getAdresse ());

// Plus tard... Ils s'agrandissent et demenagent tous les deux Adresse adresseCommune = new Adresse("8, rue de Rennes", 7000, "MONS"); personne1.setAdresse (adresseCommune); personne2.setAdresse (adresseCommune);

// Et vous annonce la nouvelle. Les references renvoyees par // personne1.getAdresse() et personne2.getAdresse() sont egales et designent le meme objet String adresse = personne1.getAdresse().getRue() + " \u00e0 " + personne2.getAdresse().getVille(); String nouvelle = personne1.getPrenom() + " et " + personne2.getPrenom() + " habitent maintenant au " + adresse; // Affiche Thomas et Sophie habitent maintenant au 8, rue de Rennes a Mons javax.swing.JOptionPane.showMessageDialog (null, nouvelle); }}

la réutilisation des classes1 sun services java programming language copyright 2005 k.allem all...

Documents