Un objet possédant un autre objet

Question

Actuellement, je suis en train de concevoir un jeu Monopoly en Java. Chaque joueur dans le jeu peut posséder différentes propriétés.

Le problème que j'ai est de savoir comment assigner différents objets de propriété à chaque joueur. J'ai à la fois une classe Player et une classe Properties. La composition serait-elle la meilleure façon de faire cela? Si oui, comment le ferais-je?

Answer 1

Je voudrais ajouter une nouvelle PropertyManager de classe. Ceci vous permet de fournir facilement des règles de gestion dans un seul endroit (bonne séparation des préoccupations) plutôt que de devoir plonger dans un groupe d'objets de joueur ou de propriété si vous optez pour la composition dans l'un ou l'autre. Cela empêchera les catégories Joueur et/ou Propriété de peser sur les règles d'achat/vente dans le futur.

public final class PropertyManager { 

    /** 
    * The PropertyManager instance, example usage: 
    * PropertyManager.INSTANCE.buyProperty(property, buyer); 
    * NB: Good candidate for dependency injection instead if you are doing this. 
    */ 
    public static final PropertyManager INSTANCE = new PropertyManager(); 

    private static final Map<Property, Player> propertyListing = new HashMap<Property, Player>(); 

    /** 
    * Buy a property from the banker, banker or property manager could maintain 
    * Collection of available properties 
    */ 
    public void buyProperty(Player buyer, Property property) { 
    if (propertyListing.containsKey(property)) { 
     throw new IllegalStateException("Unable to buy unless owner sells it"); 
    } 
    propertyListing.put(property, buyer); 
    } 

    /** 
    * Broker a transaction between two players for the sale of a property 
    */ 
    public void sellProperty(Player seller, Player buyer, Property property) { 
    if (!propertyListing.containsKey(property)) { 
     throw new IllegalStateException("Unable to sell Property which is not owned"); 
    } 
    Player owner = propertyListing.get(property); 
    if (!owner.equals(seller)) { 
     throw new IllegalStateException("Unable to sell property seller doesn't own"); 
    } 
    // TODO : Deduct/transfer monies (ensure sufficient value in buyer account etc) 
    propertyListing.put(property, buyer); 
    } 

    /** 
    * Retrieve a List of all of the Player's properties 
    */ 
    public List<Property> getProperties(Player owner) { 
    // TODO Either iterate through the propertyListing or use a second Map for player to List<Property>, NB: they should be guarded with a shared lock if you do this (threading). 
    } 

    /** 
    * Retrieve the owner of a Property or null if it is unowned 
    */ 
    @Nullable // javax annotation indiciates can be null 
    public Player getOwner(Property property) { 
    return propertyListing.get(property); 
    } 

    /** 
    * Hide the constructor as the only property manager should be INSTANCE 
    */ 
    private PropertyManager() { 
    // Prevent further instantiation 
    } 
} 

Answer 2

La composition fonctionne. Tant qu'un joueur a un objet de propriétés, et que l'objet de propriétés contient toutes les données nécessaires, cela devrait fonctionner (en supposant que vous implémentez les méthodes getter et setter nécessaires).

Answer 3

La propriété peut avoir une propriété Owner qui est le lecteur.

Vous pouvez également créer une liste sur le lecteur de propriétés.

Answer 4

Pensez-y en termes réels.

Lorsque vous êtes jouer au Monopoly et que vous achetez une propriété que vous prenez la carte de la propriété et de l'ajouter à votre liste des propriétés devant vous. Dans ce cas, vous êtes un objet Player ajoutant des objets Property à votre liste de propriétés.

public class Player 
{ 
    private List<Property> properties; 
} 

Answer 5

Vous aurez besoin de la composition et du polymorphisme.

En supposant qu'un joueur peut avoir plus d'une propriété, vous aurez besoin d'une liste de propriétés. Si les propriétés peuvent différer dans les attributs qu'elles possèdent, vous pouvez appliquer Polymorphism et Inheritance. Vous ne verrez probablement que l'héritage ci-dessous, mais vous aurez besoin de Polymorphisme lorsque vous obtiendrez les différentes propriétés et les manipulerez.

En principal:

public static void main(String args[]){ 
    Player player1 = new Player(); 

    BlackProperty blackProperty = new BlackProperty(); 
    BlueProperty blueProperty = new BlueProperty(); 

    player1.addProperty(blackProperty); 
    player1.addProperty(blueProperty); 
} 

Toutes vos classes de domaine:

public class Player{ 
    private List<Properties> propertyList; 

    // getters and setters 

    public void addProperty(Properties properties){ 
    if(this.propertyList == null){ 
     this.propertyList = new ArrayList<Properties>(); 
    } 

    this.propertyList.add(properties); 
    } 
} 

public class Properties{ 
    private int noOfFloor; 
    // getters and setters 
} 

public class BlackProperty extend Properties{ 
    private String noOfGate; 
    // getters and setters 
} 

public class BlueProperty extend Properties{ 
    private String noOfLawn; 
    // getters and setters 
}