IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Penser en Java 2nde édition - Sommaire |  Préface |  Avant-propos | Chapitre : 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15 |  Annexe : A B C D  | Tables des matières - Thinking in Java

  Chapitre 6 -  Réutiliser les classes

pages : 1 2 3 4 

Une des caractéristiques les plus excitantes de Java est la réutilisation du code. Mais pour être vraiment révolutionnaire, il faut faire plus que copier du code et le changer.

C'est l'approche utilisée dans les langages procéduraux comme C, et ça n'a pas très bien fonctionné. Comme tout en Java, la solution réside dans les classes. On réutilise du code en créant de nouvelles classes, mais au lieu de les créer depuis zéro, on utilise les classes que quelqu'un a construit et testé.

L'astuce est d'utiliser les classes sans détériorer le code existant. Dans ce chapitre nous verrons deux manières de faire. La première est plutôt directe : On crée simplement des objets de nos classes existantes à l'intérieur de la nouvelle classe. Ça s'appelle la composition, parce que la nouvelle classe se compose d'objets de classes existantes. On réutilise simplement les fonctionnalités du code et non sa forme.

La seconde approche est plus subtile. On crée une nouvelle classe comme un type d'une classe existante. On prend littéralement la forme d'une classe existante et on lui ajoute du code sans modifier la classe existante. Cette magie s'appelle l'héritage, et le compilateur fait le plus gros du travail. L'héritage est une des pierres angulaires de la programmation par objets, et a bien d'autres implications qui seront explorées au chapitre 7.

Il s'avère que beaucoup de la syntaxe et du comportement sont identiques pour la composition et l' héritage (cela se comprend parce qu'ils sont tous deux des moyens de construire des nouveaux types à partir de types existants). Dans ce chapitre, nous apprendrons ces mécanismes de réutilisation de code.

Syntaxe de composition

Jusqu'à maintenant, la composition a été utilisée assez fréquemment. On utilise simplement des références sur des objets dans de nouvelles classes. Par exemple, supposons que l'on souhaite un objet qui contient plusieurs objets de type String, quelques types primitifs et un objet d'une autre classe. Pour les objets, on met des références à l'intérieur de notre nouvelle classe, mais on définit directement les types primitifs:

// ! c06:SprinklerSystem.java
// La composition pour réutiliser du code.

class WaterSource {
  private String s;
  WaterSource() {
    System.out.println("WaterSource()");
    s = new String("Constructed");
  }
  public String toString() { return s; }
}

public class SprinklerSystem {
  private String valve1, valve2, valve3, valve4;
  WaterSource source;
  int i;
  float f;
  void print() {
    System.out.println("valve1 = " + valve1);
    System.out.println("valve2 = " + valve2);
    System.out.println("valve3 = " + valve3);
    System.out.println("valve4 = " + valve4);
    System.out.println("i = " + i);
    System.out.println("f = " + f);
    System.out.println("source = " + source);
  }
  public static void main(String[] args) {
    SprinklerSystem x = new SprinklerSystem();
    x.print();
  }
} ///:~

Une des méthodes définies dans WaterSource est spéciale : toString( ). Vous apprendrez plus tard que chaque type non primitif a une méthode toString( ), et elle est appelée dans des situations spéciales lorsque le compilateur attend une String alors qu'il ne trouve qu'un objet. Donc dans une expression:

System.out.println("source = " + source);

le compilateur voit que vous essayez d'ajouter un objet String ("source = ") à un WaterSource. Ceci n'a pas de sens parce qu'on peut seulement ajouter une String à une autre String, donc il se dit qu'il va convertir source en une String en appelant toString( ) ! Après avoir fait cela il combine les deux Strings et passe la String résultante à System.out.println( ). Dès qu'on veut permettre ce comportement avec une classe qu'on crée, il suffit simplement de définir une méthode toString( ).

Au premier regard, on pourrait supposer — Java étant sûr et prudent comme il l'est — que le compilateur construirait automatiquement des objets pour chaque référence dans le code ci-dessus ; par exemple, en appelant le constructeur par défaut pour WaterSource pour initialiser source. Le résultat de l'instruction d'impression affiché est en fait : 

valve1 = null
valve2 = null
valve3 = null
valve4 = null
i = 0
f = 0.0
source = null

Les types primitifs qui sont des champs d'une classe sont automatiquement initialisés à zéro, comme précisé dans le chapitre 2. Mais les références objet sont initialisées à null, et si on essaye d'appeler des méthodes pour l'un d'entre eux, on obtient une exception. En fait il est bon (et utile) qu'on puisse les afficher sans lancer d'exception.

On comprend bien que le compilateur ne crée pas un objet par défaut pour chaque référence parce que cela induirait souvent une surcharge inutile. Si on veut initialiser les références, on peut faire :

  1. Au moment où les objets sont définis. Cela signifie qu'ils seront toujours initialisés avant que le constructeur ne soit appelé ;
  2. Dans le constructeur pour la classe ;
  3. Juste avant d'utiliser l'objet, ce qui est souvent appelé initialisation paresseuse.

Cela peut réduire la surcharge dans les situations où l'objet n'a pas besoin d'être créé à chaque fois.

Les trois approches sont montrées ici:

// ! c06:Bath.java
// Initialisation dans le constructeur avec composition.

class Soap {
  private String s;
  Soap() {
    System.out.println("Soap()");
    s = new String("Constructed");
  }
  public String toString() { return s; }
}

public class Bath {
  private String
    // Initialisation au moment de la définition:
    s1 = new String("Happy"),
    s2 = "Happy",
    s3, s4;
  Soap castille;
  int i;
  float toy;
  Bath() {
    System.out.println("Inside Bath()");
    s3 = new String("Joy");
    i = 47;
    toy = 3.14f;
    castille = new Soap();
  }
  void print() {
    // Initialisation différée:
    if(s4 == null)
      s4 = new String("Joy");
    System.out.println("s1 = " + s1);
    System.out.println("s2 = " + s2);
    System.out.println("s3 = " + s3);
    System.out.println("s4 = " + s4);
    System.out.println("i = " + i);
    System.out.println("toy = " + toy);
    System.out.println("castille = " + castille);
  }
  public static void main(String[] args) {
    Bath b = new Bath();
    b.print();
  }
} ///:~

Notez que dans le constructeur de Bath une instruction est exécutée avant que toute initialisation ait lieu. Quand on n'initialise pas au moment de la définition, il n'est pas encore garanti qu'on exécutera une initialisation avant qu'on envoie un message à un objet — sauf l'inévitable exception à l'exécution.

Ici la sortie pour le programme est :

Inside Bath()
Soap()
s1 = Happy
s2 = Happy
s3 = Joy
s4 = Joy
i = 47
toy = 3.14
castille = Constructed

Quand print( ) est appelé, il remplit s4 donc tout les champs sont proprement initialisés au moment où ils sont utilisés.

La syntaxe de l'héritage

L'héritage est une partie primordiale de Java (et des langages de programmation par objets en général). Il s'avère qu'on utilise toujours l'héritage quand on veut créer une classe, parce qu'à moins d'hériter explicitement d'une autre classe, on hérite implicitement de la classe racine standard Object.

La syntaxe de composition est évidente, mais pour réaliser l'héritage il y a une forme distinctement différente. Quand on hérite, on dit « Cette nouvelle classe est comme l'ancienne classe ». On stipule ceci dans le code en donnant le nom de la classe comme d'habitude, mais avant l'accolade ouvrante du corps de la classe, on met le mot clé extends suivi par le nom de la classe de base. Quand on fait cela, on récupère automatiquement toutes les données membres et méthodes de la classe de base. Voici un exemple:

// ! c06:Detergent.java
// Syntaxe d'héritage & propriétés.

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();
  }
}

public class Detergent extends Cleanser {
  // Change une méthode:
  public void scrub() {
    append(" Detergent.scrub()");
    super.scrub(); // Appel de la version de la classe de base
  }
  // Ajoute une méthode à l'interface:
  public void foam() { append(" foam()"); }
  // Test de la nouvelle classe:
  public static void main(String[] args) {
    Detergent x = new Detergent();
    x.dilute();
    x.apply();
    x.scrub();
    x.foam();
    x.print();
    System.out.println("Testing base class:");
    Cleanser.main(args);
  }
} ///:~

Ceci montre un certain nombre de caractéristiques. Premièrement, dans Cleanser la méthode append( ), les Strings sont concaténées dans s en utilisant l'opérateur +=, qui est l'un des opérateurs (avec « + ») que les créateurs de Java « ont surchargé » pour travailler avec les Strings.

Deuxièmement, tant Cleanser que Detergent contiennent une méthode main( ). On peut créer une main( ) pour chacune de nos classes, et il est souvent recommandé de coder de cette manière afin de garder le code de test dans la classe. Même si on a beaucoup de classes dans un programme, seulement la méthode main( ) pour une classe invoquée sur la ligne de commande sera appelée. Aussi longtemps que main( ) est public, il importe peu que la classe dont elle fait partie soit public ou non. Donc dans ce cas, quand on écrit java Detergent, Detergent.main( ) sera appelée. Mais on peut également écrire java Cleanser pour invoquer Cleanser.main( ), même si Cleanser n'est pas une classe public. Cette technique de mettre une main( ) dans chaque classe permet de tester facilement chaque classe. Et on n'a pas besoin d'enlever la méthode main( ) quand on a finit de tester ; on peut la laisser pour tester plus tard.

Ici, on peut voir que Detergent.main( ) appelle Cleanser.main( ) explicitement, en passant les même arguments depuis la ligne de commande (quoiqu'il en soit, on peut passer n'importe quel tableau de String).

Il est important que toutes les méthodes de Cleanser soient public. Il faut se souvenir que si on néglige tout modifieur d'accès, par défaut l'accès sera « friendly », lequel permet d'accéder seulement aux membres du même package. Donc, au sein d'un même package, n'importe qui peut utiliser ces méthodes s'il n'y a pas de spécificateur d'accès. Detergent n'aurait aucun problème, par exemple. Quoiqu'il en soit, si une classe d'un autre package devait hériter de Cleanser il pourrait accéder seulement aux membres public. Donc pour planifier l'héritage, en règle générale mettre tous les champs private et toutes les méthodes public (les membres protected permettent également d'accéder depuis une classe dérivée ; nous verrons cela plus tard). Bien sûr, dans des cas particuliers on devra faire des ajustements, mais cela est une règle utile.

Notez que Cleanser contient un ensemble de méthodes dans son interface : append( ), dilute( ), apply( ), scrub( ), et print( ). Parce que Detergent est dérivé de Cleanser (à l'aide du mot-clé extends) il récupère automatiquement toutes les méthodes de son interface , même si elles ne sont pas toutes définies explicitement dans Detergent. On peut penser à l'héritage comme à une réutilisation de l'interface (l'implémentation vient également avec elle, mais ceci n'est pas le point principal).

Comme vu dans scrub( ), il est possible de prendre une méthode qui a été définie dans la classe de base et la modifier. Dans ce cas, on pourrait vouloir appeler la méthode de la classe de base dans la nouvelle version. Mais à l'intérieur de scrub( ) on ne peut pas simplement appeler scrub( ), car cela produirait un appel récursif, ce qui n'est pas ce que l'on veut. Pour résoudre ce problème, Java a le mot-clé super qui réfère à la super classe de la classe courante. Donc l'expression super.scrub( ) appelle la version de la classe de base de la méthode scrub( ).

Quand on hérite, on n'est pas tenu de n'utiliser que les méthodes de la classe de base. On peut également ajouter de nouvelles méthodes à la classe dérivée exactement de la manière dont on met une méthode dans une classe : il suffit de la définir. La méthode foam( ) en est un exemple.

Dans Detergent.main( ) on peut voir que pour un objet Detergent on peut appeler toutes les méthodes disponible dans Cleanser aussi bien que dans Detergent (e.g., foam( )).

Initialiser la classe de base

Depuis qu'il y a deux classes concernées - la classe de base et la classe dérivée - au lieu d'une seule, il peut être un peu troublant d'essayer d'imaginer l'objet résultant produit par la classe dérivée. De l'extérieur, il semble que la nouvelle classe a la même interface que la classe de base et peut-être quelques méthodes et champs additionnels. Mais l'héritage ne se contente pas simplement de copier l'interface de la classe de base. Quand on créée un objet de la classe dérivée, il contient en lui un sous-objet de la classe de base. Ce sous-objet est le même que si on crée un objet de la classe de base elle-même. C'est simplement que, depuis l'extérieur, le sous-objet de la classe de base est enrobé au sein de l'objet de la classe dérivée.

Bien sûr, il est essentiel que le sous-objet de la classe de base soit correctement initialisé et il y a un seul moyen de garantir cela: exécuter l'initialisation dans le constructeur, en appelant la constructeur de la classe de base, lequel a tous les connaissances et les privilèges appropriés pour exécuter l'initialisation de la classe de base. Java insère automatiquement les appels au constructeur de la classe de base au sein du constructeur de la classe dérivée. L'exemple suivant montre comment cela fonctionne avec 3 niveaux d'héritage : 

// ! c06:Cartoon.java
// Appels de constructeur durant l'initialisation

class Art {
  Art() {
    System.out.println("Art constructor");
  }
}

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();
  }
} ///:~

La sortie de ce programme montre les appels automatiques:

Art constructor
Drawing constructor
Cartoon constructor

On peut voir que la construction commence par la classe la plus haute dans la hiérarchie, donc la classe de base est initialisée avant que les constructeurs de la classe dérivée puisse y accéder.

Même si on ne crée pas de constructeur pour Cartoon( ), le compilateur fournira un constructeur.

Constructeurs avec paramètres

L'exemple ci-dessus a des constructeurs par défaut ; ils n'ont pas de paramètres. C'est facile pour le compilateur d'appeler ceux-ci parce qu'il n'y a pas de questions à se poser au sujet des arguments à passer. Si notre classe n'a pas de paramètres par défaut, ou si on veut appeler le constructeur d'une classe de base avec paramètre, on doit explicitement écrire les appels au contructeur de la classe de base en utilisant le mot clé super ainsi que la liste de paramètres appropriée  : super et la liste de paramètres appropriée:

// ! c06:Chess.java
// Héritage, constructeurs et paramètres.

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();
  }
} ///:~

Si on n'appelle pas le constructeur de la classe de base dans BoardGame( ), le compilateur va se plaindre qu'il ne peut pas trouver le constructeur de la forme Game( ). De plus, l'appel du constructeur de la classe de base doit être la première chose que l'on fait dans le constructeur de la classe dérivée. Le compilateur va le rappeler si on se trompe.

Ce livre a été écrit par Bruce Eckel ( télécharger la version anglaise : Thinking in java )
Ce chapitre a été traduit par Olivier Thomann ( groupe de traduction )
télécharger la version francaise (PDF) | Commandez le livre en version anglaise (amazon) | télécharger la version anglaise
pages : 1 2 3 4 
Penser en Java 2nde édition - Sommaire |  Préface |  Avant-propos | Chapitre : 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15 |  Annexe : A B C D  | Tables des matières - Thinking in Java