Solution alternative à instanceof

Version imprimable

02/06/2010, 21h10
nightcoder

Solution alternative à instanceof

Bonjour,

D'aprés vous, l'usage du mot clef instanceof est il nécessaire sur le code suivant? (sachant que le code en gras ne peut pas être modifié):

Citation:

public class Test {

public static void main(String[] args) {
Test test = new Test();
test.process();
}

public void process() {
Item[] item = new Item[3];
item[0] = new Item();
item[1] = new Item1();
item[2] = new Item2();

for(int i=0; i<item.length;i++) {
if(item[i] instanceof Item1) {
display((Item1) item[i]);
} else if(item[i] instanceof Item2) {
display((Item2) item[i]);
} else {
display(item[i]);
}
}
}

private void display(Item item) {
System.out.println("Item");
}

private void display(Item1 item) {
System.out.println("Item 1");
}

private void display(Item2 item) {
System.out.println("Item 2");
}
}

class Item {

}

class Item1 extends Item {

}

class Item2 extends Item {

}

Le but de ce topic est de définir des solutions alternatives à l'usage du mot-clef instanceof.

Merci d'avance pour votre aide.

Bonjour,

Vous pouvez utiliser le principe d'héritage :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Item {
   public boolean isItem1() {
       return false;
   }
   public boolean isItem2() {
       return false;
   }
}
 
class Item1 extends Item {
    public boolean isItem1() {
        return true;
    }
}
 
class Item2 extends Item {
   public boolean isItem2() {
       return true;
   }
}

02/06/2010, 22h25
tchize_

implémenter des méthode pour donner ton nom c'est de a redondance par rapport à getClass().getName() ;)

Ceci dit, dans le code donnée, les instanceof sont encore les plus propre pour des petites quantités. Pour beaucoup de classes différentes, il existe d'autres patterns plus souples ;)
02/06/2010, 22h30
jcdentons

Tout à fait juste, d'autant plus que nightcoder précisait :

Citation:

(sachant que le code en gras ne peut pas être modifié)
02/06/2010, 23h08
nightcoder

Bonsoir, merci pour vos réponses.

tchize_ : "Pour beaucoup de classes différentes, il existe d'autres patterns plus souples". Tu fais référence à quel pattern ? Visitor ?

Dans le cas de beaucoup de instanceof (une cinquantaine à peu prés), je pense qu'il serait plus propre d'opter pour une autre approche. Mais je ne vois pas de solutions propre dans mon cas (Sans modification des classes testé (Item)).

Si vous avez d'autres suggestions, n'hesitez pas.

Merci encore :D.

Bonjour,

En respectant tes "règles du jeu" tu devrais pouvoir utiliser un adptateur:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
public class Test {
 
  interface IAdaptateur {
    void display();
  }
 
  class Adaptateur implements IAdaptateur {
    private Item item;
 
    public Adaptateur(Item item) {
      this.item = item;
    }
 
    @Override
    public void display() {
      System.out.println("Item = " + item.toString());
    }
  }
 
  class Adaptateur1 implements IAdaptateur {
    private Item1 item;
 
    public Adaptateur1(Item1 item) {
      this.item = item;
    }
 
    @Override
    public void display() {
      System.out.println("Item 1 = " + item.toString());
    }
  }
 
  class Adaptateur2 implements IAdaptateur {
    private Item2 item;
 
    public Adaptateur2(Item2 item) {
      this.item = item;
    }
 
    @Override
    public void display() {
      System.out.println("Item 2 = " + item.toString());
    }
  }
 
  public static void main(String[] args) {
    Test test = new Test();
    test.process();
  }
 
  public void process() {
    IAdaptateur[] adaptateur = new IAdaptateur[3];
    adaptateur[0] = new Adaptateur(new Item());
    adaptateur[1] = new Adaptateur1(new Item1());
    adaptateur[2] = new Adaptateur2(new Item2());
 
    for (int i = 0; i < adaptateur.length; i++) {
      adaptateur[i].display();
    }
  }
}
 
class Item {
 
}
 
class Item1 extends Item {
 
}
 
class Item2 extends Item {
 
}

03/06/2010, 07h22
tchize_

Citation:

Envoyé par nightcoder

Bonsoir, merci pour vos réponses.

tchize_ : "Pour beaucoup de classes différentes, il existe d'autres patterns plus souples". Tu fais référence à quel pattern ? Visitor ?

sleroux a répondu en partie à la question. ;)

Simplement, quand on a beaucoup de classes différentes (en plus de beaucoup de instanceof), pour factoriser un peu le code, on établit une convention de nommage sur les adaptateur (exemple: dois prendre le nom de la classe suivie de Adaptater) et on crée l'adaptateur par réflexion:

Code:

Class.forName(item.getClass().getName()+"Adapter")

, ce qui permet assez souplement à chacune de tes librairies de fournir son propre set d'adaptateur pour les Item qu'elle embarque ;)
05/06/2010, 02h53
nightcoder

Merci pour vos réponses! :ccool:
05/06/2010, 11h52
tchize_

je rajoute que c'est la méthode utiliser par la classe BeanInfo, qui permet de fournir des éditeurs spécifique à tes beans ;)