Discussion :

[domiq44]

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 :

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
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 :

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
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 :

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
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 :

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

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 :

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
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 :

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

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.

[eulbobo]

Code :

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

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 :

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

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 :

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

1
2
 
	private static <T extends A> String lulu(T a)

Est interprétée comme ceci au final :

Code :

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

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 :

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

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

[domiq44]

Merci

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 :

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

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.

[eulbobo]

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 :

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

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 :

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

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

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
 
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 :

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
 
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 :

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

[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...

[domiq44]

On revient hélas au point de départ

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 :

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

[eulbobo]

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

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.

[adiGuba]

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 :

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

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 :

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

toto("Hello");

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


a++

[joel.drigo]

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 :

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

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 :

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

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 :

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

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

Code :

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

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 :

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

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).

[domiq44]

Merci aussi joel.drigo.

Doc quelque chose comme ça :

Code :

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

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

Code :

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

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

et

Code :

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

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 :

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

[eulbobo]

Plus simple :

Code :

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

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

Code :

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

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 :

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

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 :

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
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

[adiGuba]

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 :

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

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 :

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

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

a++