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 ?

[roudoudouduo]

Premier problèle de conception : les classes internes ne sont ni lisible ni pratique, crée un fichier par classe c'est franchement plus clair.

Je te conseille de créer une classe AbstractItem qui definira ta méthode bingo1 et bingo2 (et qui implemente item)

Tu géreras en interne une liste d'abstractItem et pour l'exterieur une liste d'item et tu masqueras l'implémentation abstraite pas la même occasion.

Je répond vite fait car j'ai peu de temps. Hésite pas à poser des questions si tu n'as pas compris.

[wazup]

Une question bête (sans doute) :

Pourquoi deux noms différents de méthode (bingo et bingo2) ?

[wazup]

Je ne sais pas ce qu'en pense roudoudouduo, mais tu devrais regarder du côté du DP Abstract factory.

[roudoudouduo]

La remarque de wazup est très juste, la méthode Bingo2 ne sert à rien du tout.

De plus les classes CarreA et RondA ne servent à rien non plus.


En reprenant la méthode que je t'ai cité cela donnerait :

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

abstract class AbstractItem implements Item {

   public abstract void bingo();

}

public class Carre extends AbstractItem{
	public Carre(){
	}

	public void affiche(){
		System.out.println("Je suis un Carre;");
	}

	public void bingo(){
		System.out.println("Bingoooooooo Carre");
	}
}

public class Rond extends AbstractItem{
	public Rond(){
	}

	public void affiche(){
		System.out.println("Je suis un Rond;");
	}

	public void bingo(){
		System.out.println("Bingoooooooo Rond");
	}
}

final public class Test {
	public static void main(String[] args){
		List<AbstractItem> itemList = new ArrayList<AbstractItem>();
		AbstractItem carre = new Carre();
		AbstractItem rond = new Rond();
		itemList.add(carre);
		itemList.add(rond);

               for(AbstractItem item : itemList){
                    item.bingo();
               }
	}
}

[wazup]

Comme je ne connais pas les contraintes de départ, à la rigueur, tu peux avoir

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
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 void bingo(){
                        bingo2();
                }
		  

        }

... et le reste est à l'avenant.


A voir si le nom de la fonction bingo2 relève de contraintes d'existant ou de ton bricolage

Dans le second cas il faut implémenter comme te l'indique roudoudouduo