Discussion :

[cnguyen]

Bonjour,

Je souhaiterai vous soumettre un problème de conception pour un projet en JAVA.

Pour faire simple nous avons la situation suivante :

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
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
75
76
77
78
79
80
81
82
83
84
85
 
import java.util.ArrayList;
 
 
public class Test{
 
	/**
         * Interface Item
         */
	static interface Item {
		public void affiche();
	}
 
 
	/**
         * Abstract Carre
         */
	static abstract class Carre implements Item{
		public Carre(){
		}
 
		public abstract void affiche();
 
		public void bingo(){
			System.out.println("Bingoooooooo Carre");
		}
	}
 
	/**
         * Abstract Rond
         */
	static abstract class Rond implements Item{
		public Rond(){
		}
 
		public abstract void affiche();
 
		public void bingo2(){
			System.out.println("Bingoooooooo Rond");
		}
	}
 
	/**
         * CarreA 
         */
	static class CarreA extends Carre{
		public CarreA(){
		}
 
		public void affiche(){
			System.out.println("Je suis un Carre;");
		}
	}
 
	/**
         * RondA 
         */
	static class RondA extends Rond{
		public RondA(){
		}
 
		public void affiche(){
			System.out.println("Je suis un Rond;");
		}
	}
 
	public static void main(String[] args){
		ArrayList<Item> itemList = new ArrayList<Item>();
		CarreA p = new CarreA();
		RondA s = new RondA();
		itemList.add(p);
		itemList.add(s);
 
		/*
		 * On veut pouvoir acceder a la methode bingo ou bingo2 a partir de l'ArrayList d'Item
		 * sans avoir a faire de tests "instanceof" suivi d'un cast :
		 * if(itemList.get(0) instanceof CarreA)
		 * 		((CarreA)itemList.get(0)).bingo();
		 * if(itemList.get(0) instanceof RondA)
		 * 		((RondA)itemList.get(0)).bingo2();
		 */
 
 
	}
}

Nous utilisons une librairie externe qui prend plusieurs paramètres. L'un d'entre eux est une ArrayList. Cette ArrayList doit pouvoir contenir aussi bien des Carre que des Rond. En parcourant l'ArrayList<Item> nous souhaitons avoir accès aux méthodes : bingo pour Carre et bingo2 pour Rond sans avoir à les déclarer dans l'interface (pour ne pas avoir des méthodes void sans code à l'intérieur).

J'avais demandé à mon professeur de conception un moyen d'accéder à ces méthodes sans avoir à faire le cast ni le test instanceof. Celui-ci m'a dit qu'en effet cela était très très moche, que j'avais donc un gros problème de conception et que je devais y réfléchir. Nous venons tout juste de commencer le cours de conception et nous n'avons pas vu tous les design pattern. Auriez-vous quelques pistes sur un pattern à utiliser ou du moins une façon propre de le faire ?

PS : J'ai aussi posté dans le forum de conception n'étant pas très sûr de l'endroit où le mettre.

[adiGuba]

Salut,


Je ne comprend pas pourquoi tu ne veux pas déclarer la méthode bingo() dans l'interface Item ?

a++

[gifffftane]

Mon opinion est que, en POO, il faut réfléchir à partir d'objets du monde réel... pas de RondA et CarreA qui font bingo.

Ensuite, par rapport à cette compréhension du monde réel, et ce que peut exprimer un langage comme java, il faut faire un certain nombre de compromis. Et il arrive souvent que, en java, les cast, instanceof, et autres méthodes vides ne sont pas de si mauvais compromis que cela. Ils indiquent certes des faiblesses de conception, que l'on peut qualifier de très très moches si l'on veut... d'autres les qualifieront de fonctionnalités extrêmement puissantes, voir par exemple les discours autour des XXXListener et XXXAdapter.

En tous les cas, il n'existe pas en java d'astuces pour appeler la méthode bingo d'un objet CarreA à partir d'un objet déclaré Item, heureusement.

Ce que les professeurs aiment beaucoup en ce genre de cas est l'usage du pattern Visitor.

[cnguyen]

Tout d'abord merci d'avoir pris le temps de me répondre.

En fait la méthode bingo était un exemple. Le truc c'est qu'on nous dit "Il faut respecter : une classe, une responsabilité".

Notre classe abstraite carré se trouve actuellement dans un état ou elle gère différentes responsabilités (gestion d'un "stock" de carrés, mouvements du carré dans une frame, interactions avec la souris ..." et il en est de même pour les ronds, mais les services pour les ronds et les carrés sont totalement différents (pas d'évènements de la souris, pas de rotation ...) ). En gros je souhaiterai redécouper nos classes abstraites, seulement cela ne me semble pas trop possible.

Nous avions pensé à laisser les cast ou alors aussi mettre toutes les méthodes dans l'interface puis dans chaque classe abstraite qui ne rend pas ce service faire des return null.

En tout cas le pattern visitor semble répondre à nos besoins, il me reste donc à bien comprendre comment il marche.

Merci.

[adiGuba]

Je penses que tu devrais donner plus de détail concret sur ta Conception, et sur ce que tu veux faire précisément plutôt que de te tourner vers un Design Pattern comme cela car il semble correspondre à "tes besoins"...


Perso je trouve que "tes besoins" ne sont pas très clair !

a++

[blueman1]

Que penserais tu d'utiliser le pattern décorateur ?

( c'est celui qui est utilisé pour l'API IO...) il permet d'ajouter ou d'enlever des comportements dynamiques a un classe d'objets.

Exemple, si tu veux un carré qui fait bingo, tu instanciera un new Bingo(new Carre()), mais tu pourra également faire un new Bingo2(new Carre()) si ca te chante.

Edit:

En meme temps c'est vrai qu'après relecture attentice de ton message, que tu devrais préciser les besoins.

Surtout pourquoi ne pas utiliser simplement les interfaces avec l'interface Carre et Rond qui hériteraient de Forme_géo?