Chapitre 12 - Identification dynamique de type

pages : 1 2 3

Bien sûr, cet exemple est imaginaire - vous utiliseriez probablement un attribut de classe (static) pour chaque type que vous incrémenteriez dans le constructeur pour mettre à jour les compteurs. Vous feriez cela si vous avez accès au code source de ces classes et pouvez le modifier. Comme ce n'est pas toujours le cas, le RTTI est bien pratique.

Utiliser les littéraux de classe

Il est intéressant de voir comment l'exemple précédent PetCount.java peut être réécrit en utilisant les littéraux de classe. Le résultat est plus satisfaisant sur bien des points :

//: c12:PetCount2.java
// Utiliser les littéraux de classe.
import java.util.*;

public class PetCount2 {
  public static void main(String[] args)
  throws Exception {
    ArrayList pets = new ArrayList();
    Class[] petTypes = {
      // Littéraux de classe:
      Pet.class,
      Chien.class,
      Carlin.class,
      Chat.class,
      Rongeur.class,
      Gerbil.class,
      Hamster.class,
    };
    try {
      for(int i = 0; i < 15; i++) {
        // on ajoute 1 pour éliminer Pet.class:
        int rnd = 1 + (int)(
          Math.random() * (petTypes.length - 1));
        pets.add(
          petTypes[rnd].newInstance());
      }
    } catch(InstantiationException e) {
      System.err.println("Instantiation impossible");
      throw e;
    } catch(IllegalAccessException e) {
      System.err.println("Accès impossible");
      throw e;
    }
    HashMap h = new HashMap();
    for(int i = 0; i < petTypes.length; i++)
      h.put(petTypes[i].toString(),
        new Counter());
    for(int i = 0; i < pets.size(); i++) {
      Object o = pets.get(i);
      if(o instanceof Pet)
        ((Counter)h.get("class Pet")).i++;
      if(o instanceof Chien)
        ((Counter)h.get("class Chien")).i++;
      if(o instanceof Carlin)
        ((Counter)h.get("class Carlin")).i++;
      if(o instanceof Chat)
        ((Counter)h.get("class Chat")).i++;
      if(o instanceof Rongeur)
        ((Counter)h.get("class Rongeur")).i++;
      if(o instanceof Gerbil)
        ((Counter)h.get("class Gerbil")).i++;
      if(o instanceof Hamster)
        ((Counter)h.get("class Hamster")).i++;
    }
    for(int i = 0; i < pets.size(); i++)
      System.out.println(pets.get(i).getClass());
    Iterator keys = h.keySet().iterator();
    while(keys.hasNext()) {
      String nm = (String)keys.next();
      Counter cnt = (Counter)h.get(nm);
      System.out.println(
        nm.substring(nm.lastIndexOf('.') + 1) +
        " quantité: " + cnt.i);
    }
  }
} ///:~

Ici, le tableau typenames a été enlevé, on préfère obtenir de l'objet Class les chaînes identifiant les types. Notons que ce système permet au besoin de différencier classes et interfaces.

On peut aussi remarquer que la création de petTypes ne nécessite pas l'utilisation d'un block try puisqu'il est évalué à la compilation et ne lancera donc aucune exception, contrairement à Class.forName().

Quand les objets Pet sont créés dynamiquement, vous pouvez voir que le nombre aléatoire généré est compris entre un (ndt inclus) et petTypes.length (ndt exclus), donc ne peut pas prendre la valeur zéro. C'est parce que zéro réfère à Pet.class, et que nous supposons que créer un objet générique Pet n'est pas intéressant. Cependant, comme Pet.class fait partie de petTypes, le nombre total d'animaux familiers est compté.

Un instanceof dynamique

La méthode isInstance de Class fournit un moyen d'appeler dynamiquement l'opérateur instanceof. Ainsi, toutes ces ennuyeuses expressions instanceof peuvent être supprimées de l'exemple PetCount :

//: c12:PetCount3.java
// Utiliser isInstance().
import java.util.*;

public class PetCount3 {
  public static void main(String[] args)
  throws Exception {
    ArrayList pets = new ArrayList();
    Class[] petTypes = {
      Pet.class,
      Chien.class,
      Carlin.class,
      Chat.class,
      Rongeur.class,
      Gerbil.class,
      Hamster.class,
    };
    try {
      for(int i = 0; i < 15; i++) {
        // Ajoute 1 pour éliminer Pet.class:
        int rnd = 1 + (int)(
          Math.random() * (petTypes.length - 1));
        pets.add(
          petTypes[rnd].newInstance());
      }
    } catch(InstantiationException e) {
      System.err.println("Instantiation impossible");
      throw e;
    } catch(IllegalAccessException e) {
      System.err.println("Accès impossible");
      throw e;
    }
    HashMap h = new HashMap();
    for(int i = 0; i < petTypes.length; i++)
      h.put(petTypes[i].toString(),
        new Counter());
    for(int i = 0; i < pets.size(); i++) {
      Object o = pets.get(i);
      // Utiliser isInstance pour automatiser
      // l'utilisation des instanceof :
      // Ndt: Pourquoi ce ++j ????
      for (int j = 0; j < petTypes.length; ++j)
        if (petTypes[j].isInstance(o)) {
          String key = petTypes[j].toString();
          ((Counter)h.get(key)).i++;
        }
    }
    for(int i = 0; i < pets.size(); i++)
      System.out.println(pets.get(i).getClass());
    Iterator keys = h.keySet().iterator();
    while(keys.hasNext()) {
      String nm = (String)keys.next();
      Counter cnt = (Counter)h.get(nm);
      System.out.println(
        nm.substring(nm.lastIndexOf('.') + 1) +
        " quantity: " + cnt.i);
    }
  }
} ///:~

On peut noter que l'utilisation de la méthode isInstance() a permis d'éliminer les expressions instanceof. De plus, cela signifie que de nouveaux types d'animaux familiers peuvent être ajoutés simplement en modifiant le tableau petTypes ; le reste du programme reste inchangé (ce qui n'est pas le cas lorsqu'on utilise des instanceof).

instanceof vs. équivalence de classe

Lorsque vous demandez une information de type, il y a une différence importante entre l'utilisation d'une forme de instanceof (instanceof ou isInstance(), qui produisent des résultats équivalents) et la comparaison directe des objets Class. Voici un exemple qui illustre cette différence :

//: c12:FamilyVsExactType.java
// La différence entre instanceof et class

class Base {}
class Derived extends Base {}

public class FamilyVsExactType {
  static void test(Object x) {
    System.out.println("Teste x de type " +
      x.getClass());
    System.out.println("x instanceof Base " +
      (x instanceof Base));
    System.out.println("x instanceof Derived " +
      (x instanceof Derived));
    System.out.println("Base.isInstance(x) " +
      Base.class.isInstance(x));
    System.out.println("Derived.isInstance(x) " +
      Derived.class.isInstance(x));
    System.out.println(
      "x.getClass() == Base.class " +
      (x.getClass() == Base.class));
    System.out.println(
      "x.getClass() == Derived.class " +
      (x.getClass() == Derived.class));
    System.out.println(
      "x.getClass().equals(Base.class)) " +
      (x.getClass().equals(Base.class)));
    System.out.println(
      "x.getClass().equals(Derived.class)) " +
      (x.getClass().equals(Derived.class)));
  }
  public static void main(String[] args) {
    test(new Base());
    test(new Derived());
  }
} ///:~

La méthode test() effectue une vérification du type de son argument en utilisant les deux formes de instanceof. Elle récupère ensuite la référence sur l'objet Class et utilise == et equals() pour tester l'égalité entre les objets Class. Le résultat est le suivant :

Teste x de type class Base
x instanceof Base true
x instanceof Derived false
Base.isInstance(x) true
Derived.isInstance(x) false
x.getClass() == Base.class true
x.getClass() == Derived.class false
x.getClass().equals(Base.class)) true
x.getClass().equals(Derived.class)) false
Teste x de type class Derived
x instanceof Base true
x instanceof Derived true
Base.isInstance(x) true
Derived.isInstance(x) true
x.getClass() == Base.class false
x.getClass() == Derived.class true
x.getClass().equals(Base.class)) false
x.getClass().equals(Derived.class)) true

Il est rassurant de constater que instanceof et isIntance() produisent des résultats identiques, de même que equals() et ==. Mais les tests eux-mêmes aboutissent à des conclusions différentes. instanceof teste le concept de type et signifie « es-tu de cette classe, ou d'une classe dérivée ? ». Autrement, si on compare les objets Class en utilisant ==, il n'est plus question d'héritage - l'objet est de ce type ou non.

La syntaxe du RTTI

Java effectue son identification dynamique de type (RTTI) à l'aide de l'objet Class, même lors d'un transtypage. La classe Class dispose aussi de nombreuses autres manières d'être utilisée pour le RTTI.

Premièrement, il faut obtenir une référence sur l'objet Class approprié. Une manière de le faire, comme nous l'avons vu dans l'exemple précédent, est d'utiliser une chaîne de caractères et la méthode Class.forName(). C'est très pratique car il n'est pas nécessaire d'avoir un objet de ce type pour obtenir la référence sur l'objet Class. Néanmoins, si vous avez déjà un objet de ce type, vous pouvez retrouver la référence à l'objet Class en appelant une méthode qui appartient à la classe racine Object : getClass(). Elle retourne une référence sur l'objet Class représentant le type actuel de l'objet. Class a de nombreuses méthodes intéressantes, comme le montre l'exemple suivant :

//: c12:ToyTest.java
// Teste la classe Class.

interface HasBatteries {}
interface Waterproof {}
interface ShootsThings {}
class Toy {
  // Commenter le constructeur par
  // défault suivant pour obtenir
  // NoSuchMethodError depuis (*1*)
  Toy() {}
  Toy(int i) {}
}

class FancyToy extends Toy
    implements HasBatteries,
      Waterproof, ShootsThings {
  FancyToy() { super(1); }
}

public class ToyTest {
  public static void main(String[] args)
  throws Exception {
    Class c = null;
    try {
      c = Class.forName("FancyToy");
    } catch(ClassNotFoundException e) {
      System.err.println("Ne trouve pas FancyToy");
      throw e;
    }
    printInfo(c);
    Class[] faces = c.getInterfaces();
    for(int i = 0; i < faces.length; i++)
      printInfo(faces[i]);
    Class cy = c.getSuperclass();
    Object o = null;
    try {
      // Nécessite un constructeur par défaut :
      o = cy.newInstance(); // (*1*)
    } catch(InstantiationException e) {
      System.err.println("Instanciation impossible");
      throw e;
    } catch(IllegalAccessException e) {
      System.err.println("Accès impossible");
      throw e;
    }
    printInfo(o.getClass());
  }
  static void printInfo(Class cc) {
    System.out.println(
      "Class nom: " + cc.getName() +
      " est une interface ? [" +
      cc.isInterface() + "]");
  }
} ///:~

On peut voir que la classe FancyToy est assez compliquée, puisqu'elle hérite de Toy et implémente les interfaces HasBatteries, Waterproof et ShootThings. Dans main(), une référence de Class est créée et initialisée pour la classe FancyToy en utilisant forName() à l'intérieur du block try approprié.

La méthode Class.getInterfaces() retourne un tableau d'objets Class représentant les interfaces qui sont contenues dans l'objet en question.

Si vous avez un objet Class, vous pouvez aussi lui demander la classe dont il hérite directement en utilisant la méthode getSuperclass(). Celle-ci retourne, bien sûr, une référence de Class que vous pouvez interroger plus en détail. Cela signifie qu'à l'éxécution, vous pouvez découvrir la hiérarchie de classe complète d'un objet.

La méthode newInstance() de Class peut, au premier abord, ressembler à un autre moyen de cloner() un objet. Néanmoins, vous pouvez créer un nouvel objet avec newInstance() sans un objet existant, comme nous le voyons ici, car il n'y a pas d'objets Toy - seulement cy qui est une référence sur l'objet Class de y. C'est un moyen de construire un « constructeur virtuel », qui vous permet d'exprimer « je ne sais pas exactement de quel type vous êtes, mais créez-vous proprement ». Dans l'exemple ci-dessus, cy est seulement une référence sur Class sans aucune autre information à la compilation. Et lorsque vous créez une nouvelle instance, vous obtenez une référence sur un Object. Mais cette référence pointe sur un objet Toy. Bien entendu, avant de pouvoir envoyer d'autres messages que ceux acceptés par Object, vous devez l'examiner un peu plus et effectuer quelques transtypages. De plus, la classe de l'objet créé par newInstance() doit avoir un constructeur par défaut. Dans la prochaine section, nous verrons comment créer dynamiquement des objets de classes utilisant n'importe quel constructeur, avec l'API de réflexion Java.

La dernière méthode dans le listing est printInfo(), qui prend en paramètre une référence sur Class, récupère son nom avec getName(), et détermine si c'est une interface avec isInterface().

Le résultat de ce programme est :

Class nom: FancyToy est une interface ? [false]
Class nom: HasBatteries est une interface ? [true]
Class nom: Waterproof est une interface ? [true]
Class nom: ShootsThings est une interface ? [true]
Class nom: Toy est une interface ? [false]

Ainsi, avec l'objet Class, vous pouvez découvrir vraiment tout ce que vous voulez savoir sur un objet.

Réflexion : information de classe dynamique

Si vous ne connaissez pas le type précis d'un objet, le RTTI vous le dira. Néanmoins, il y a une limitation : le type doit être connu à la compilation afin que vous puissiez le détecter en utilisant le RTTI et faire quelque chose d'intéressant avec cette information. Autrement dit, le compilateur doit connaître toutes les classes que vous utilisez pour le RTTI.

Ceci peut ne pas paraître une grande limitation à première vue, mais supposons que l'on vous donne une référence sur un objet qui n'est pas dans l'espace de votre programme. En fait, la classe de l'objet n'est même pas disponible lors de la compilation. Par exemple, supposons que vous récupériez un paquet d'octets à partir d'un fichier sur disque ou via une connexion réseau et que l'on vous dise que ces octets représentent une classe. Puisque le compilateur ne peut pas connaître la classe lorsqu'il compile le code, comment pouvez vous utilisez cette classe ?

Dans un environnement de travail traditionnel cela peut sembler un scénario improbable. Mais dès que l'on se déplace dans un monde de la programmation plus vaste, il y a des cas importants dans lesquels cela arrive. Le premier est la programmation par composants, dans lequel vous construisez vos projets en utilisant le Rapid Application Development (RAD) dans un constructeur d'application. C'est une approche visuelle pour créer un programme (que vous voyez à l'écran comme un « formulaire » (form)) en déplaçant des icônes qui représentent des composants dans le formulaire. Ces composants sont alors configurés en fixant certaines de leurs valeurs. Cette configuration durant la conception nécessite que chacun des composants soit instanciable, qu'il dévoile une partie de lui-même et qu'il permette que ses valeurs soient lues et fixées. De plus, les composants qui gèrent des événements dans une GUI doivent dévoiler des informations à propos des méthodes appropriées pour que l'environnement RAD puisse aider le programmeur à redéfinir ces méthodes de gestion d'événements. La réflexion fournit le mécanisme pour détecter les méthodes disponibles et produire leurs noms. Java fournit une structure de programmation par composants au travers de JavaBeans (décrit dans le chapitre 13).

Ce livre a été écrit par Bruce Eckel ( télécharger la version anglaise : Thinking in java )
Ce chapitre a été traduit par Daniel Le Berre ( 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

Penser en Java 2nde édition

Thinking in Java