Médiaforma

Java – Des generics dans des classes et des interfaces

Print Friendly

Considérez le code suivant :

public class GenericsTypeAvant {

    private Object t;
     public Object get() {
        return t;
    }

    public void set(Object t) {
        this.t = t;
    }

    public static void main(String args[]){
        GenericsTypeAvant type = new GenericsTypeAvant();
        type.set(12);
        String str = (String) type.get();
    }
}
Ce code se compile correctement, mais il produit une erreur CassCastException à l’exécution. En effet, le nombre 12 ne peut pas être casté en un String :

 

 

Considérez maintenant le code suivant :

public class GenericsTypeMaintenant<T> {

    private T;

    public T get(){
        return this.t;
    }

    public void set(T t1){
        this.t=t1;
    }

    public static void main(String args[]){
        GenericsTypeMaintenant<String> type = new GenericsTypeMaintenant<>(); // Type String
        type.set("chaîne"); // OK

        GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>(); //Type Integer
        type1.set(12); //OK
        //type1.set("abc"); //Invalide

        GenericsTypeMaintenant type2 = new GenericsTypeMaintenant(); //Type quelconque
        type2.set("texte"); //OK
        type2.set(10); //Valide

    }
}

Le type T est spécifié dans la classe :

public class GenericsTypeMaintenant<T>

Lors de l’instanciation d’un objet de classe GenericsTypeMaintenant, on définit le type de l’objet passé. Par exemple, un type String :

GenericsTypeMaintenant<String> type = new GenericsTypeMaintenant<>();

On passe alors un objet de type String au setter après l’instanciation de la classe :

type.set("chaîne");

Si on lui passe un autre type, une erreur sera déclenchée à la compilation.

Par exemple, cette instruction :

type.set(12);

Provoque une erreur à la compilation :

 

 

Lors de l’instanciation d’un objet GenericsTypeMaintenant, on peut aussi définir un type Integer :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();

 

Dans ce cas, les instructions suivantes ne produiront aucune erreur de compilation :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();
type1.set(12); //OK

 

Par contre, ces instructions provoqueront une erreur à la compilation :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();
type1.set("abc"); //Invalide

 

Si aucun type n’est spécifié :

GenericsTypeMaintenant type2 = new GenericsTypeMaintenant();

 

Une valeur de type quelconque peut être passée au setter. Ainsi, ces deux instructions sont correctes :

type2.set("texte");
type2.set(10);
Vous avez aimé cet article ? Partagez-le avec vos réseaux...
 
Comments

No comments yet.

Leave a Reply