Discussion :

[Fifan31]

Bonjour à tous,
voilà mon problème: j'utilise une API qui me permet d'ajouter des critère dans un objet requête. Voici une présentation de l'interface que je dois utiliser :

Code :

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

1
2
3
4
5
6
7
8
public Interface ISelectRequestBuilder {
  void addBlocType1(Type1 arg);
  void addBlocType2(Type2 arg);
  void addBlocType2(List<Type2> arg);
  void addBlocType3(Type3 arg);
  void addBlocType3(List<Type3> arg);
  ....
}

Tous les Type1, Type2, Type3... dérivent d'un même type. Appelons le "AbstractType".

Ce que j'essaie de faire, sans succès pour l'instant , c'est un adapteur générique du genre:

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 Class MonAdapteur implements ISelectRequestBuilder{
  private ISelectRequestBuilder adpatee = null;
  public MonAdapteur(ISelectRequestBuilder adaptee){
    this.adaptee = adaptee;
  }
 
  // Les methodes adapatees
  public void addBlocType2(Type2 arg){
    adaptee.addBlocType2(arg);
  }
 
  // La partie adapteur
  public void addBloc(List<T extends AbstractType> arg){
    // Si la liste est null ou vide 
    if (criteres == null || criteres.size() < 1) {
	// On ne fait rien
	return;
    }
 
    // Recuperation du premier element pour determiner le type
    T critere = criteres.get(0);
    if (critere instanceof Type1) {
	adaptee.addBlocType1((Type1) critere);
    }
    // else if .....
  }
}

J'ai pensé à paramétré ma classe

Code :

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

1
2
3
4
public Class MonAdapteur<T extends AbstractType> implements ISelectRequestBuilder ....
 
MonAdapteur<Type3> monAdapteur = new MonAdapteur<Type3>(..);
.....

mais je ne voit pas de grande différence

Ma question est la suivante: existe-t-il une façon de faire qui permette d'éviter d'utiliser 'instanceof' et d'utiliser le polymorphisme ?


Merci pour votre aide

[dingoth]

Je crois que java seul peut t'aider à résoudre ce souci. Pas même besoin de types paramétrés, Java fera tout seul la distinction :

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
public abstract class TypeAbstrait {
  ...
}
 
public class TypeA extends TypeAbstrait {
  ...
}
 
public class TypeB extends TypeAbstrait {
  ...
}
 
public class TypeC extends TypeB { // Cas spécial, mais pris également en compte par Java.
  ....
}
 
public interface SelectBuilder {
  public void addBloc (TypeA... a);
  public void addBloc (TypeB... b);
  public void addBloc (TypeC... c);
}
 
public class SelectBuilderAdapter implements SelectBuilder {
  public void addBloc (TypeA... a) {
    ...
  }
  public void addBloc (TypeB... b) {
    ...
  }
  public void addBloc (TypeC... c) {
    ...
  }
}

Le seul inconvénient est si tu ne sais pas quel type tu reçois. En gros, si tu castes un objet TypeA en TypeAbstrait et que tu le passes. Dans ce cas, tu dois passer par des instanceof. Mais ce cas ne devrait pas se produire, si l'on en croit ton interface.

[Fifan31]

Merci pour cette réponse rapide
J'avais déjà essayé ça mais le PB c'est qu'il y a aussi des listes et j'ai une erreur de compil quand je fais:

Code :

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

1
2
public void addBloc(List<TypeA> arg){...}
public void addBloc(List<TypeB> arg) {...}

Je pense avoir une solution avec l'ellipse:

Code :

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

1
2
3
4
5
6
7
8
public void addBloc(TypeA... criteres){
  if (criteres == null || criteres.length < 1){ return;}
  if (criteres.length == 1) {
    addBlocTypeA(criteres[0]);
  } else { // Plusieurs elements
    addBlocTypeA(Arrays.asList(criteres));
  }
}

Si quelqu'un voit une autre solution, je suis preneur. (C'est toujours mieux quand on a le choix. Encore faut-il faire le bon ou le moins pire )

Sinon, je marquerai le fil résolu demain.

Merci encore

[gifffftane]

Je ne comprends pas très bien l'ensemble.

En tous les cas, un adaptateur puissant pour toutes sortes d'interfaces est le Proxy, mais là c'est le règne du instanceof.

[dingoth]

Code :

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

1
2
public void addBloc(List<TypeA> arg){...}
public void addBloc(List<TypeB> arg) {...}

Effectivement, c'est bien une erreur de compilation. Car même si conceptuellement ce sont deux types distincts (une liste de TypeA, une liste de TypeB), en réalité, java ne voit qu'un seul type : java.util.List et tu as donc deux méthodes avec la même signature, ce qui pose problème. C'est pour ça que j'ai proposé des ellipses dans ma solution. C'est sensiblement différent de la liste, mais utilisable (de manière peu conventionelle, je l'admets) le cas échéant avec l'instruction suivante

Code :

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

List<TypeA>.toArray(new TypeA[XXX]);

[Fifan31]

C'est pour ça que j'ai proposé des ellipses dans ma solution.

Merci dingoth, j'avais lu un peu rapidement ta solution et n'avais pas bien vu les elipses
Pour l'instant, c'est la solution que je retiens avec la convertion de tableau en liste pour les appels
Par contre, une précision, je ne peux pas modifier l'interface ISelectRequestBuilder. Elle est issue d'un autre projet; c'est donc une archive (jar) que j'utilise. C'est la raison pour la quelle je fait cet adaptateur.
Merci pour vos contributions. Si quelqu'un a une autre (meilleure) solution ou tout simplement pour confirmer que celle-ci est bonne ... n'hésitez pas et faites nous part de vos obervations.
Le sujet sera marqué résolu demain.