Discussion :

[abysr]

Bonjour je suis étudiant et on nous demande dans le cadre d'un petit projet Java de créer un jeu de plateau, et pour la création des joueur on nous impose le design pattern "Factory" : il y aura entre 2 et 4 joueurs , au début de la partie ils sont tous identiques a part leurs nom, je ne vois pas le lien avec Factory qui est censé via une classe instancier des objets différents! Sachant que mon idée de départ est de demander le nombre de joueur dans la méthode main et selon ce nombre, créer le nombre de joueur correspondant.
si quelqu'un a un début d'idée ce serait super cool!

[joel.drigo]

Salut,

Le fait que les joueurs soient identiques au départ ne veut pas dire qu'il s'agit d'une seule et même instance. Cela signifie juste que leurs informations sont identiques. Donc on peut en déduire que ces informations peuvent être connues de la fabrique. Ensuite, le fait que le nom soit propre à chaque joueur nécessite de passer le nom en paramètre.

On peut donc imaginer une fabrique comme ça :

Code pseudocode :

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
fabriqueDeJoueur {
 
   joueur fabriqueJoueur( nom ) {
 
 
        nouveau joueur
 
        nom du joureur <- nom
 
        information 1 du joueur <- une valeur
        information 2 du joueur <- une autre valeur
 
        ...
 
        retourner joueur
 
   }
 
}

On peut procéder par mutateur (des méthodes setNom(), setInfo()...), ou par initialisation interne pour les variables de valeurs fixées, et par le constructeur pour le nom


Ensuite, il suffit d'appeler la méthode de fabrication autant de fois que nécessaire, tout simplement.

Le modèle UML standard de fabrique montre souvent des abstractions :


Si tu dois implémenter ce modèle exactement, soit avec un Joueur générique, soit avec un Joueur abstrait, tu feras une méthode protected spécifique dans l'abstraction/générique de fabrique pour remplir les valeur de l'abstraction/générique de joueur, su tu choisis de peupler les informations fixées par mutateur, méthode qui peut être appelée par la méthode de la fabrique concrète ou redéfinie.

[abysr]

Merci c'est bien plus clair pour moi, voilà j'ai fais trois classe simpliste juste pour le mecanisme:

ma fabrique:

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 CreatePlayer {
 
 
Player CreatPlayer(String name){
 
p = new Player(name);
p.setName(name);
return p;
}
 
private Player p;
 
}

puis class Player:

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
class Player
{
 
	public Player(String name)
	{
		this.name = name;
 
	}
 
    public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAccount() {
		return account;
	}
	public void setAccount(int account) {
		this.account = account;
	}
	public int getPosition() {
		return position;
	}
	public void setPosition(int position) {
		this.position = position;
	}
	private boolean alive; 
	private String name;
	private int account = 800;
	private int position =1;
}

puis mon Programme prinicpal:

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
import java.util.Scanner;
 
public class Play
{
	public static void main (String[] args)
	{
 
Scanner sc = new Scanner(System.in);
 
System.out.println("Enter the name of the player please :");
String nom = sc.nextLine();
 
 
 
		CreatePlayer fab = new CreatePlayer();
		Player one = fab.CreatPlayer(nom);
		System.out.println("You are welcome mr " + one.getName());
		System.out.println("Your account is : " +one.getAccount());
 
		System.out.println("And you are at the : " +one.getPosition()+" position");
		System.out.println("I hope you a good play");
 
 
 
	}
}

voilà ce que j'obtiens:
Enter the name of the player please :
Aldo
You are welcome mr Aldo
Your account is : 800
And you are at the : 1 position
have a good play


Je suis satisfait dans l'ensemble même si j'ai encore bien à faire.
Mais j'ai une question si je dois créer trois joueurs par exemple, j'aurai un problème car dans mon code j'ai une ligne de ce type:

Code :

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

Player one = fab.CreatPlayer(nom);

Ce qui signifie que si je fais une boucle pour créer trois joueurs, je vais créer un joueur Player one, puis ensuite je vais l'écraser pour faire le deuxième...
Comment faire pour créer Player one, puis Player two, puis Player three??? et que ces trois "Players" reste en mémoire!

[joel.drigo]

Ce qui signifie que si je fais une boucle pour créer trois joueurs, je vais créer un joueur Player one, puis ensuite je vais l'écraser pour faire le deuxième...
Comment faire pour créer Player one, puis Player two, puis Player three??? et que ces trois "Players" reste en mémoire!

Tu écraseras juste la référence contenue dans p, mais ça ne changera rien aux instances précedemment créées. SI tu fais :

Code :

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

1
2
3
4
5
List<Player> players = new ArrayList<>();
for(String name : new String[]{"paul", "marie", "jean"} ) {
    players.add( playerFactory.CreatPlayer(name) );
}
System.out.println(players);

Tu auras bien 3 instances de joueus différentes affichées à la fin.

Mais une fabrique n'est pas censée mémoriser les instances qu'elle crée. De toute manière, avec ton implémentation, il n'y a aucun moyen de récupérer la dernière instance crée :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class PlayerFactory {
 
   public Player createPlayer(String name){
 
      Player p = new Player(name);
      // p.setName(name); // inutile, puisqu'on passe déjà name en argument du constructeur
      return p;
 
   }
 
}

Maintenant, on peut faire une notion de "cache", pour pouvoir accèder plusieurs fois au même joueur, sans le recréer à chaque fois. On est plus vraiment dans la pure fabrique :

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 PlayerFactoryWithCache {
 
   private static Map<String, Player> players = new HashMap<>();
 
   public Player getOrCreatePlayer(String name){
 
      synchronized( players ) {
           Player player = players.get( name );
           if ( player==null ) {
               player = new Player(name);
               map.put( name, player );
               // player.setName(name); // Pour que ça fonctionne bien sans effet de bord, il faudra supprimer ce setName de la classe Player
           }
           return player;
 
      }
 
   }
 
}

[abysr]

Merci beaucoup pour ta réponse, la notion de "Factory" est assez clair pour moi.