Composition du diagramme de classes UML avec hiérarchies de classes
Je me demandais si je pouvais modéliser la relation entre les deux hiérarchies de classes ci-dessous, comme je l'ai fait:
Le code qui représenterait la signification de ceci serait quelque chose comme:
public abstract class Car
{
protected Engine engine;
}
public class StreetCar extends Car
{
public StreetCar()
{
engine = new StreetEngine();
}
}
...et de même pour la classe OffroadCar, il ferait quelque chose comme engine = new OffroadEngine(). Je n'ai rien inclus sur la méthode accelerate (), ce n'est pas pertinent.
Je veux juste savoir si la composition est modélisée correctement ou si elle est redondante ou même faux d'ajouter que de nombreuses flèches de composition.
1 answers
Avant de répondre à la question, c'est l'un de ces cas, où est une bonne idée de séparer les relations de hiérarchie des relations de composition, comme si elles étaient différentes sortes de diagrammes.
Remarque: J'ai ajouté Engine au diagramme, en tant que préfixe "protégé" et "Classe", pour éviter toute confusion.
(1) Diagramme de composition
Un objet de "CarClass" est composé par 1 seul objet de "EngineClass".
..............................................................................
..+-------------------------------------+........+-------------------------+..
..| <<abstract>> |........| <<abstract>> |..
..| CarClass |........| EngineClass |..
..+-------------------------------------+........+-------------------------+..
..| [#] Engine: EngineClass |<*>-----+ [+] startEngine(): void |..
..+-------------------------------------+........+-------------------------+..
..| [+] acelerate(): void <<virtual>> |.....................................
..+-------------------------------------+.....................................
..............................................................................
(2.1) Diagramme d'héritage
Un l'objet de "CarClass" peut avoir des classes enfants, selon certains scénarios.
...........................................
..+-------------------------------------+..
..| <<abstract>> |..
..| CarClass |..
..+-------------------------------------+..
..| [#] Engine: EngineClass |..
..+-------------------------------------+..
..| [+] acelerate(): void <<override>> |..
..+-----------------+-------------------+..
.................../.\.....................
................../...\....................
.................+--+--+..............................................................
....................|.................................................................
....................+------------------------------------------+......................
....................|..........................................|......................
..+-----------------+-------------------+....+-----------------+-------------------+..
..| <<concrete>> |....| <<concrete>> |..
..| StreetCarClass |....| OffRoadCarClass |..
..+-------------------------------------+....+-------------------------------------+..
..| [+] acelerate(): void <<override>> |....| [+] acelerate(): void <<override>> |..
..+-------------------------------------+....+-------------------------------------+..
......................................................................................
(2.2) Diagramme d'héritage
Un objet de "EngineClass" peut avoir des classes enfants, selon certains scénarios.
...........................................
..+-------------------------------------+..
..| <<abstract>> |..
..| EngineClass |..
..+-------------------------------------+..
..| [+] acelerate(): void <<override>> |..
..+-----------------+-------------------+..
.................../.\.....................
................../...\....................
.................+--+--+..............................................................
....................+------------------------------------------+......................
....................|..........................................|......................
....................|..........................................|......................
..+-----------------+-------------------+....+-----------------+-------------------+..
..| <<concrete>> |....| <<concrete>> |..
..| StreetEngineClass |....| OffRoadEngineClass |..
..+-------------------------------------+....+-------------------------------------+..
..| [+] startEngine(): void <<override>>|....| [+] startEngine(): void<<override>> |..
..+-------------------------------------+....+-------------------------------------+..
......................................................................................
3 Réponse
Maintenant, c'est un cas, où une classe a un unleast un membre composant, et son type peut être remplacé, lorsque la classe principale est remplacée. Ceci est parfois appelé le "Modèle de logiciel de Hiérarchie Paralell" ou " Logiciel de Hiérarchie Double Modèle".
Vous n'avez mentionné que 2 sous-classes de chaque classe principale, mais, en réalité, il pourrait y en avoir plus.
Habituellement, je fais des graphiques comme celui-ci de 2 façons. Un, je fais le premier diagramme, en ajoutant un commentaire, qui indique que c'est ce cas.
3.1 Principal Paralèlle Hiérarchie Diagramme
..............................................................................
..+-------------------------------------+........+-------------------------+..
..| <<abstract>> |........| <<abstract>> |..
..| CarClass |........| EngineClass |..
..+-------------------------------------+........+-------------------------+..
..| [#] Engine: EngineClass |<*>-----+ [+] startEngine(): void |..
..+-------------------------------------+........+------------+------------+..
..| [+] acelerate(): void <<virtual>> |.....................|...............
..+--------------+----------------------+.....................|...............
.................|............................................|...............
.................+--------------------------------------------+...............
.................|............................................................
........+--------+-------+....................................................
........| Note: |....................................................
........| Paralell /....................................................
........| Hierarchy /| ...................................................
........| / |....................................................
........+-------------/--+....................................................
..............................................................................
Le deuxième cas, c'est quand les deux classes ont des classes enfants qui ajoutent des membres.
3.2 Diagramme de hiérarchie supplémentaire Paralell
..............................................................................
..+---------------------------------------+........+-------------------------+..
..| <<concrete>> |........| <<concrete>> |..
..| OffRoadCarClass |........| OffRoadEngineClass |..
..+---------------------------------------+........+-------------------------+..
..| [+] createEngine(): void <<override>> |<*>-----+ [+] startEngine(): void |..
..+---------------------------------------+........| [+] nitroLevel(): void |..
..| [+] useNitro(): void |........+------------+------------+..
..| [+] acelerate(): void <<override>> |.....................|...............
..+--------------+------------------------+.....................|...............
.................|..............................................|...............
.................+----------------------------------------------+...............
.................|............................................................
........+--------+-------+....................................................
........| Note: |....................................................
........| Paralell /....................................................
........| Hierarchy /| ...................................................
........| / |....................................................
........+-------------/--+....................................................
..............................................................................
Je peux ajouter diagrammes supplémentaires, si necesarilly.
4 Montrez-moi le code de
Afin de gérer ces hiérarchies "parallèles", généralement, la création des membres composites est gérée par une méthode surchargée.
public abstract class EngineClass
{
public void startEngine() { ... }
} // EngineClass
public abstract class CarClass
{
protected EngineClass engine;
public CarClass()
{
// ...
}
public EngineClass createEngine()
{
EngineClass Result = new EngineClass();
return Result;
}
public void start()
{
this.Engine = createEngine();
}
} // CarClass
public class StreetCarClass extends CarClass
{
public StreetCarClass()
{
// ...
}
@override
public EngineClass createEngine()
{
EngineClass Result = new StreetCarEngineClass();
return Result;
}
} // StreetCarClass
public class OffRoadCarClass extends CarClass
{
public OffRoadCarClass()
{
// ...
}
@override
public EngineClass createEngine()
{
EngineClass Result = new OffRoadCarEngineClass();
return Result;
}
} // OffRoadCarClass
public class ExampleClass
{
public static main()
{
EngineClass OffRoadCar = new OffRoadCarClass();
OffRoadCar.start();
}
} // OffRoadCarClass
Santé.
P.s. Puis-je, ur, haz un Fishburguer ?