Généricité sur les méthodes

Version imprimable

Bonjour,

Je suis en présence de code que je cherche à simplifier (c'est un « test case »).

J'ai les 2 classes suivantes A et B :

Code:

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
28
29
30
31
32
33
34
public class A {
	private String ma1;
	private String ma2;
	private String ma3;
 
	public String getMa1() {
		return ma1;
	}
 
	public void setMa1(String ma1) {
		this.ma1 = ma1;
	}
 
	public String getMa2() {
		return ma2;
	}
 
	public void setMa2(String ma2) {
		this.ma2 = ma2;
	}
 
	public String getMa3() {
		return ma3;
	}
 
	public void setMa3(String ma3) {
		this.ma3 = ma3;
	}
 
	@Override
	public String toString() {
		return "A [ma1=" + ma1 + ", ma2=" + ma2 + ", ma3=" + ma3 + "]";
	}
}

Code:

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
28
29
30
31
32
33
34
public class B {
	private String mb1;
	private String mb2;
	private String mb3;
 
	public String getMb1() {
		return mb1;
	}
 
	public void setMb1(String mb1) {
		this.mb1 = mb1;
	}
 
	public String getMb2() {
		return mb2;
	}
 
	public void setMb2(String mb2) {
		this.mb2 = mb2;
	}
 
	public String getMb3() {
		return mb3;
	}
 
	public void setMb3(String mb3) {
		this.mb3 = mb3;
	}
 
	@Override
	public String toString() {
		return "B [mb1=" + mb1 + ", mb2=" + mb2 + ", mb3=" + mb3 + "]";
	}
}

Et voici schématisé le programme principale :

Code:

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
28
29
30
31
32
33
34
35
36
public class App1 {
 
	public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
 
		toto(a);
		toto(b);
	}
 
	private static <T> void toto(T obj) {
		if (obj instanceof A) {
			System.out.println("lulu: " + lulu((A) obj));
		}
		if (obj instanceof B) {
			System.out.println("lulu: " + lulu((B) obj));
		}
		System.out.println("class: " + obj.getClass().getName());
		System.out.println("value: " + obj.toString());
	}
 
	private static String lulu(A a) {
		return a.getMa1();
	}
 
	private static String lulu(B b) {
		return b.getMb2();
	}
}

qui me retourne cela:

Code:

1
2
3
4
5
6
lulu: aaa111
class: domiq.generics.A
value: A [ma1=aaa111, ma2=aaa222, ma3=aaa333]
lulu: bbb222
class: domiq.generics.B
value: B [mb1=bbb111, mb2=bbb222, mb3=bbb333]

Ce que je veux faire, c'est de rendre générique la méthode lulu().

J'ai pensé à ça mais Eclipse me retourne une erreur car cela doit être faux.

Code:

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
28
29
30
31
public class App2 {
 
	public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
 
		toto(a);
		toto(b);
	}
 
	private static <T> void toto(T obj) {
		System.out.println("lulu: " + lulu(obj));          // <== ERREUR !!! ???
		System.out.println("class: " + obj.getClass().getName());
		System.out.println("value: " + obj.toString());
	}
 
	private static <T extends A> String lulu(T a) {
		return a.getMa1();
	}
 
	private static <T extends B> String lulu(T b) {
		return b.getMb2();
	}
}

L'erreur est la suivante :

Code:

1
2
Bound mismatch: The generic method lulu(T) of type App2 is not applicable for the arguments (T). The inferred type T 
 is not a valid substitute for the bounded parameter <T extends A>

Est-ce que quelqu'un peut m'aider ?
Merci.

Code:

1 2 3 4 5 6 private static <T> void toto(T obj) { System.out.println("lulu: " + lulu(obj)); // <== ERREUR !!! ??? System.out.println("class: " + obj.getClass().getName()); System.out.println("value: " + obj.toString()); }
Dans cette méthode, tu dis "je passe un objet d'un type inconnu à ma méthode". Toi tu sais que tu y passe une instance de A ou de B, mais le compilateur quand il lit ça, il interprète ça comme

Code:

private static void toto(Object obj)

Du coup, quand après tu essayes de le passer dans une méthode qui doit étendre A, forcement ça devient plus compliqué (il te demanderai un cast explicite si tu passais un Object, comme dans ton code plus haut)

Ton autre méthode que déclares comme :
Code:

1 2 private static <T extends A> String lulu(T a)
Est interprétée comme ceci au final :
Code:

1 2 private static String lulu(A a)
D'où le blocage. Tu as un Object, pas un A

Pour aller un peu plus loin, quand tu écris : void <T extends A> String lulu(T a), ça veut dire que tu as une classe inconnue nommée T qui étend A. Mais si dans une autre fonction tu as aussi un void <T> String lulu(T a), ca ne sera pas forcement la même classe.
Pour s'assurer que la classe décrite par ton T soit la même dans tout ton code, il faut le définir au niveau de la classe.

Et il y a un twist :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class MaClasse<T extends Thread>{ void faitDesTrucs(T valeur) throws SQLException{ // ici, on veut une instance d'un objet qui étend Thread valeur.getName(); // méthode de Thread } <T extends Closeable> void fermeToi(T close) throws IOException{ // le T défini ici n'a rien à voir avec le type défini dans la classe close.close(); // méthode de closeable }
J'espere que c'est clair

Merci

Citation:

Envoyé par eulbobo

eulbobo

pour ta réponse.

Je comprends ce que tu me dis.

Mais est-il possible de faire, dans la méthode toto(), un appel à la méthode lulu(), qui soit propre à A ou propre à B, sans faire appel à instanceof ?

C'est-à-dire, sans avoir à faire ceci :
Code:

1 2 3 4 5 6 7 8 9 10 private static <T> String lulu(T obj) { String value = null; if (obj instanceof A) { value = ((A) obj).getMa1(); } if (obj instanceof B) { value = ((B) obj).getMb2(); } return value; }
Oui, j'ai bien compris le twist. Et il est vrai que je ne l'avais pas vu. Donc merci.

Si tes objets n'ont aucun lien hiérarchique non

Mais rien ne t'empêche d'avoir des signatures de méthodes spécifiques pour ce qui a besoin de l'être :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
         private static  void toto(A obj) {
	        System.out.println("lulu: " + obj.getMa1());
		blabla(obj);
	}
 
        private static  void toto(B obj) {
	        System.out.println("lulu: " + obj.getMb2());
		blabla(obj);
	}
 
       private static <T> void blabla(T obj) {
		System.out.println("class: " + obj.getClass().getName());
		System.out.println("value: " + obj.toString());
	}

Après, si ta méthode lulu n'est là que pour renvoyer une valeur spécifique, vise l'interface !

Code:

1
2
3
4
5
 
public interface ILulu{
     String getLulu();
     setLulu(String lulu);
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public class A implements ILulu{
	private String ma1;
	private String ma2;
	private String ma3;
 
	public String getMa1() {
		return ma1;
	}
 
	public String setMa1(String ma1) {
		this.ma1 = ma1;
	}
 
     public String getLulu(){
           return getMa1();
     }
     public setLulu(String lulu){
          setMa1(lulu);
     }

Pareil pour B

Et ensuite, tu as ton code

Code:

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
 
public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
 
		toto(a);
		toto(b);
	}
 
	private static <T extends ILulu> void toto(T obj) {
		System.out.println("lulu: " + lulu(obj));
		System.out.println("class: " + obj.getClass().getName());
		System.out.println("value: " + obj.toString());
	}
 
	private static <T extends ILulu> String lulu(T a) {
		return a.getLulu();
	}

Ou sans les générics qui n'apportent rien ici

Code:

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
 
public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
 
		toto(a);
		toto(b);
	}
 
	private static void toto(ILulu obj) {
		System.out.println("lulu: " + lulu(obj));
		System.out.println("class: " + obj.getClass().getName());
		System.out.println("value: " + obj.toString());
	}
 
	private static String lulu(ILulu a) {
		return a.getLulu();
	}

12/06/2015, 14h09
domiq44

Merci encore eulbobo pour ta réponse.

En fait le programme a été schématisé afin de mettre en évidence les problèmes.
Les méthodes sont bien plus complexes et ne font pas qu'afficher du texte.
Donc KO pour la dernière méthode avec l'interface.

Mais je regarde ta méthode avec l'utilisation de signatures de méthodes spécifiques pour ce qui a besoin de l'être...

On revient hélas au point de départ :calim2:

C'est-à-dire, comment appeler, à partir d'une méthode générique, une méthode propre à A et/ou une méthode propre à B ?

Je pense qu'il faut absolument passer par l'utilisation commune de instanceof et de cast.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 private static void toto(A obj) { System.out.println("toto> value=" + obj.getMa1()); lulu(obj); } private static void toto(B obj) { System.out.println("toto> value=" + obj.getMb2()); lulu(obj); } private static <T> String lulu(T obj) { String value = null; if (obj instanceof A) { bidon((A) obj); } if (obj instanceof B) { bidon((B) obj); } return value; }

12/06/2015, 14h29
eulbobo

Tu donnes la réponse toi même dans ta question

Citation:

Envoyé par domiq44

C'est-à-dire, comment appeler, à partir d'une méthode générique, une méthode propre à A et/ou une méthode propre à B ?

Tu veux faire un truc générique qui soit apte à gérer des cas spécifiques... C'est pas trop possible ça monsieur !

Dernière solution, c'est de faire une classe abstraite de test, et de créer autant de classe de test spécifiques qui permettront de tester ce qui est spécifique (polymorphisme, héritage, tout ça)

Sinon on peut aussi passer par la réflexivité et l'introspection, mais je pense que ça va rendre les choses plus complexes pour pas grand chose.

Citation:

Envoyé par domiq44

C'est-à-dire, comment appeler, à partir d'une méthode générique, une méthode propre à A et/ou une méthode propre à B ?

Je pense qu'il faut absolument passer par l'utilisation commune de instanceof et de cast.

Tu veux à la fois faire du code générique ET ultra spécifique.
C'est normal d'avoir à vérifier le type à un moment où à un autre puisque tu n'as pas de hiérarchie commune.

Au passage ce code est bien meilleure que celui que tu avais posté dans ton premier message :
Code:

1 2 3 4 5 private static <T> void toto(T obj) { System.out.println("lulu: " + lulu(obj)); // <== ERREUR !!! ??? System.out.println("class: " + obj.getClass().getName()); System.out.println("value: " + obj.toString()); }
En effet si ce code était valide, que se passerait-t-il dans le cas où on utiliserait le code suivant parfaitement valide :

Code:

toto("Hello");

:arrow: lulu(String) n'existe pas !!!!

a++

Salut,

A noter, que lorsqu'on a une telle problématique à gérer dans une application, on peut utiliser le Design Pattern "Adapteur".

Mettons qu'on ait une classe A d'une API avec une méthode print() :
Code:

1 2 3 4 5 6 7 public class A { public void print(Printer printer) { ... } }
Et une classe B d'une API avec une méthode imprimer()
Code:

1 2 3 4 5 6 7 public class B { public Resultat imprimer() { ... } }
Et qu'on veuille gérer l'impression de manière générique que les objets soient de l'API 1 ou 2 :

On peut faire :
Code:

1 2 3 4 5 6 public interface PrintAdapter { void print(); }
Code:

1 2 3 4 5 6 7 8 9 10 public class PrintAdaptedA extends A implements PrintAdapter { public void print() { Printer printer = PrintChooser.getPrinter(); // je mets n'importe quoi, c'est juste pour l'exemple print(printer); } /* ... */ }
Code:

1 2 3 4 5 6 7 8 9 public class PrintAdaptedB extends B implements PrintAdapter { public void print() { imprimer(); } /* ... */ }
Ainsi, dans notre programme, à l'aide d'une fabrique par exemple, on fabrique toujours des instances adaptées, dont les versions A ou B pourront être manipulées par leur API respective, mais qu'on pourra imprimer par appel d'une méthode commune à nous.

On peut également faire que l'Adapter soit un wrapper (il encapsule l'instance de A ou B), si les instances sont produites par les API en question, avec une fabrique d'adapteurs. De cette manière, on peut gérer par exemple de manière identique (et générique donc) des objets qui pourraient être d'une part produite par une API de type abstraction de communication avec un CMS pour des objets distants et d'autre par par une API locale parsant du xml pour des objets locaux (ou copie de distant en mode déconnecté par exemple).

Merci aussi joel.drigo.

Doc quelque chose comme ça :

Code:

1
2
3
4
public interface MyAdapter {
	public void toto();
	public String lulu();
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class AobjAdapter extends A implements MyAdapter {
 
	@Override
	public void toto() {
		System.out.println("lulu: " + lulu());
		System.out.println("classA: " + super.getClass().getName());
		System.out.println("valueA: " + super.toString());
	}
 
	@Override
	public String lulu() {
		return getMa1();
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BobjAdapter extends B implements MyAdapter {
 
	@Override
	public void toto() {
		System.out.println("lulu: " + lulu());
		System.out.println("classB: " + super.getClass().getName());
		System.out.println("valueB: " + super.toString());
	}
 
	@Override
	public String lulu() {
		return getMb2();
	}
}

Puis enfin:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package domiq.adapter;
 
public class App6 {
 
	public static void main(String[] args) {
		AobjAdapter a = new AobjAdapter();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
 
		BobjAdapter b = new BobjAdapter();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
 
		a.toto();
		b.toto();
	}
}

Plus simple :

Code:

1
2
3
4
public interface MyAdapter {
	public String lulu();
        public String getFatherName();
}

Code:

1
2
3
4
5
6
7
8
9
10
11
public class AobjAdapter extends A implements MyAdapter {
 
	@Override
	public String lulu() {
		return getMa1();
	}
 
        public String getFatherName(){
                return A.class.getName();
        }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
public class BobjAdapter extends B implements MyAdapter {
 
	@Override
	public String lulu() {
		return getMb2();
	}
 
        public String getFatherName(){
                return B.class.getName();
        }
}

Code:

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
package domiq.adapter;
 
public class App6 {
 
	public static void main(String[] args) {
		AobjAdapter a = new AobjAdapter();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
 
		BobjAdapter b = new BobjAdapter();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
 
		toto(a);
		toto(b);
	}
 
        private static  void toto(MyAdapter obj) {
		System.out.println("lulu: " + obj.getLulu());
		System.out.println("class: " + obj.getFatherName());
		System.out.println("value: " + obj.toString());
	}
}

Ne mélange pas les rôles : ton adaptateur sert à donner un point commun à tes objets, c'est tout.
Les tests communs eux se font dans ta classe App6.

EDIT : adaptation pour le nom de la classe père

Avec Java 8 et les références de méthodes on peut même faire plus succinct en utilisant la fonction en paramètre :
Code:

1 2 3 4 5 private static <T> void toto(T obj, Function<T,String> luluFunction) { System.out.println("lulu: " + luluFunction.apply(obj)); System.out.println("class: " + obj.getFatherName()); System.out.println("value: " + obj.toString()); }
Qu'on utilisera comme ceci :
Code:

1 2 3 4 5 A a = ... B b = ... lulu(a, A::getMa1); lulu(b, B::getMb2);
a++