Discussion :

[Tesing]

Bonjour,

Je bute sur un exercice du livre Thinking in Java (jusqu'à présent je les enchainais tous ).
J'ai pas envie de payer 20$ pour le corrigé de tous les exercices qui sont à télécharger sur le site du livre (surtout qu'ils sont pas disponibles pour la dernière édition), donc si quelqu'un a la solution, je suis preneur.
Voici donc l'énoncé (libre de droit) :

Create a generic class Generic1<T> with a single method that takes an argument of type T. Create a second generic class Generic2<T> with a single method that returns an argument of type T. Write a generic method with a contravariant argument of the first generic class that calls its method. Write a second generic method with a covariant argument of the second generic class that calls its method. Test using the typeinfo.pets library.

La libraire typeinfo.pets contient une hiérarchie de classes avec Pet comme super classe et des classes enfants comme Cat, Dog, etc.

Alors les pros ?

[Jimmy_]

Bonjour,

Elle est où la question ?

[Tesing]

Je cherche la solution à l'exercice. Je n'ai pas vraiment de question précise dessus car je ne suis pas sur d'avoir bien compris l'énoncé. Toute piste est la bienvenue.

[Jimmy_]

Bon juste une piste alors, comme ça a vue de nez comme ça parle de contravariant et de covariant, c'est certainement pour te faire utiliser des wildcards avec les mots clés extends et super.
Comme ça tu passes d'un type à l'autre.

Bon courage, mais bon les exercices des bouquins c'est un peu bof, en pratique il vaut mieux simplifier que de s'amuser a ce genre de manip.

[Tesing]

Je suis bien d'accord qu'en pratique il faut simplifier.
Voilà ce que j'avais commencé à écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Generic1<T> {
 
  public void meth(T t) { }
 
}
 
class Generic2<T> {
 
  public T meth(T t) {
    return t;
  }
 
  public void meth1(Generic1<? super Pet> u) {
    u.meth(new Cat());
  }
 
  public void meth2(Generic2<? extends Pet> v) {
    // Je vois pas comment appeler v.meth() ici ..
  }
 
}
 
class Pet { }
 
class Cat extends Pet { }

[adiGuba]

Salut,


La méthode de la seconde classe se contente de retourner un élément de type T sans paramètre, donc il suffit de faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class Generic2<T> {
 
  public T meth() {
    return t;
  }
 
  public void meth2(Generic2<? extends Pet> v) {
    Pet pet = v.meth();
  }
 
}

Mais bon perso je ne trouve pas cela très clair présenté comme cela.

En général je préfère utiliser les collections pour parler de cela...



a++

[thelvin]

Write a generic method with a contravariant argument of the first generic class that calls its method. Write a second generic method with a covariant argument of the second generic class that calls its method. Test using the typeinfo.pets library.

Vu que ce sont les méthodes, qui doivent être génériques, j'ai l'impression que ce serait plutôt ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class TestGeneric1And2 {
 
  public static <T> void testGen1(Generic1<? super T> gen1, T t) {
    System.out.println("Called testGen1");
    gen1.method(t);
  }
 
  public static <T> T testGen2(Generic2<? extends T> gen2) {
    System.out.println("Called testGen2");
    return gen2.method();
  }
 
  public static void main(String[] args) {
    Generic1<Pet> gen1 = new Generic1<Pet>();
    testGen1(gen1, new Dog());
 
    Generic2<Cat> gen2 = new Generic2<Cat>(new Cat());
    Pet pet = gen2.method();
    pet.doSomething();
  }
 
}

Ce qui se voit mieux avec les collections :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public static <T> void insertInMiddle(List<? super T> list, T item) {
  list.add(list.size()/2, item);
}
 
public static <T> T getMiddleElement(List<? extends T> list) {
  return list.get(list.size()/2);
}
 
public static void main(String[] args) {
  List<Pet> pets = new ArrayList<Pet>();
  pets.add(new Dog());
  pets.add(new Cat());
  pets.add(new Rat());
 
  System.out.println(pets);
  insertInMiddle(pets, new Bird());
  System.out.println(pets);
 
  List<Dog> dogs = new ArrayList<Dog>();
  dogs.add(new Dog());
  dogs.add(new Dog());
  dogs.add(new Dog());
 
  System.out.println(dogs);
  Pet pet = getMiddleElement(dogs);
  System.out.println(pet);
}

[Tesing]

Ok, merci, effectivement, ça me paraît juste.