UML中基数、关联与泛化的协作及Player-Field场景建模咨询

First: Will Incorrect Modeling Lead to 9 of Each Subclass? #

Absolutely—if you model separate associations between Player and Endfield, plus Player and Startfield, each with a multiplicity of 9, that’s exactly what’ll happen. UML treats these as independent constraints: one requiring 9 Endfields, another requiring 9 Startfields, totaling 18 instances instead of the 9 you need. That’s why we need to anchor the multiplicity to the parent Field class, not its subclasses.

Correct Modeling Approach #

Let’s break this down step by step:

1. Build the Generalization Hierarchy

   • Mark Field as an abstract class (italicize its name in UML or add the {abstract} stereotype to make this explicit).
   • Draw generalization arrows (empty triangle pointing toward the parent) from Endfield to Field, and another from Startfield to Field. This tells UML that both subclasses are valid, concrete implementations of the abstract Field.

2. Create the Player-Field Association

   • Draw an association line between Player and Field.
   • On the Player end, set multiplicity to 1 (each group of fields belongs to exactly one player).
   • On the Field end, set multiplicity to 9 (each player owns exactly 9 Field instances total).
   • Since Field is abstract, these 9 instances must be Endfield or Startfield objects—UML prevents instantiating abstract classes, so the subclasses automatically fill this role.

3. Add Clear Constraints (Optional but Recommended)

   • To eliminate any ambiguity, attach a UML constraint (enclosed in curly braces) to the association or Player class. For example:

     Player { self.fields->size() = 9 }
     

     (Assuming fields is the name of the attribute in Player that holds the Field instances.)
   • If you want to add optional rules (like "at least 1 Startfield per Player"), extend the constraint:

     Player { 
       self.fields->size() = 9,
       self.fields->select(oclIsTypeOf(Startfield))->size() >= 1 
     }
     

Key Mistakes to Skip #

• Don’t link Player directly to subclasses: This creates separate multiplicity rules for each subclass, breaking your "total 9" requirement.
• Don’t skip marking Field as abstract: If you leave it concrete, someone might accidentally instantiate a raw Field object, which defeats your subclass-only intent.

内容的提问来源于stack exchange，提问作者Heuwinkelsen