web-dev-qa-db-fra.com

Relations UML - ligne pointillée vs ligne continue

Quelle est la différence entre ces 2 relations?

enter image description here

Edit: si vous pouviez fournir un exemple de code simple illustrant la différence, ce serait vraiment utile!

language-agnosticumlrelationshipclass-diagram
43
NPS

J'essaie de donner des exemples simples des deux types de lignes.

Dans le premier diagramme, la ligne continue indique une association:

PlantUML diagram of a directed association

Si les classes étaient déclarées en Java, ceci ressemblerait à ClassA stocker une référence à ClassB en tant qu'attribut (elle pourrait être transmise au constructeur, créée, etc.). Donc, vous pourriez voir quelque chose comme:

public class ClassA {
    ClassB theClassB = ...
    ...
}

Dans le deuxième diagramme, il montre une dépendance:

PlantUML diagram of dependency

Une dépendance est beaucoup plus faible qu'une association. Pour citer UML Distilled:

Avec les classes, les dépendances existent pour diverses raisons: une classe envoie un message à une autre; une classe en a une autre dans ses données; une classe en mentionne une autre en tant que paramètre d'une opération. [...] Vous utilisez des dépendances chaque fois que vous souhaitez montrer comment des modifications apportées à un élément peuvent modifier d'autres éléments.

Encore une fois, en utilisant Java, il existe quelques exemples: un argument de type ClassB est passé à une méthode ou une méthode déclare une variable locale de type ClassB:

public class ClassA {
    ...
    public void someMethod(ClassB arg1) {...}
    ...
    public void someOtherMethod() {
        ClassB localReferenceToClassB = ...
    }
    ...
}

D'autres manières ClassA pourrait dépendre sur ClassB sans association (liste non exhaustive):

  • ClassB a une méthode statique que ClassA appelle
  • ClassA intercepte des exceptions de type ClassB
  • Chaque fois que ClassB est modifié, ClassA doit également être modifié (par exemple, une logique est partagée)
24
Fuhrmanator

Cette page Web en dit assez, je pense: http://www.classdraw.com/help.htm Le texte suivant en provient, mais devrait suffire à comprendre la différence, à mon avis.

Donc, fondamentalement, la ligne continue est une association et la ligne pointillée est une dépendance.

Les associations peuvent également être unidirectionnelles, une classe connaissant l'autre classe et la relation, mais pas l'autre. De telles associations nécessitent une flèche ouverte pour pointer sur la classe connue et seule la classe connue peut avoir un nom de rôle et une multiplicité. Dans l'exemple, la classe Client connaît un nombre quelconque de produits achetés, mais la classe Produit ne connaît rien des clients. La multiplicité "0 .. *" signifie zéro ou plus.

Une dépendance est une relation faible entre deux classes et est représentée par une ligne pointillée. Dans l'exemple, il existe une dépendance entre Point et LineSegment, car l'opération draw () de LineSegment utilise la classe Point. Cela indique que LineSegment doit connaître Point, même s'il ne possède aucun attribut de ce type. Cet exemple montre également comment les diagrammes de classes sont utilisés pour se concentrer sur ce qui est important dans le contexte, car vous ne voudriez normalement pas montrer de telles dépendances détaillées pour toutes vos opérations de classe.

Comme ma réputation n'est que de 8, je ne peux pas placer les images elles-mêmes, mais on peut toujours les trouver sur la page Web que j'ai mentionnée au début.

[EDIT]

Je n'ai pas d'exemples de code ici, mais la façon dont je l'expliquerais personnellement est aussi simple qu'une voiture et une porte.

Quand une voiture a une porte (ou plus) c'est juste une voiture

Car --- has a --> Door

Mais quand vous avez une porte qui peut être ouverte la classe de porte aura une fonction comme

public void openDoor(){
this.open();
}

Pour utiliser la fonction ci-dessus la voiture devra créer une instance de la porte

Class Car(){
Door door1 = new Door();

door1.open();
}

De cette façon, vous avez créé une dépendance.

Ainsi, la ligne continue ne fait que pointer un objet (1) vers un autre objet (2), mais lorsque vous commencez à utiliser l'objet (1), il devient une dépendance.

J'espère que ça va faire;)

19
Mathieu Brouwers

La ligne en pointillé indique la dépendance à (dans le sens de la flèche). En supposant que votre code source soit parfaitement assemblé dans des fichiers et des en-têtes distincts pour chaque classe, il s’avère simplement que le code comprend la ligne #include ClassB.h.

CEPENDANT Le fait est que toutes les relations de classe (généralisation, réalisation, composition, agrégation, association, etc.) héritent toutes de la relation de dépendance. Pour cette raison, je n'utilise jamais de flèches en pointillé pour documenter le code. Dans la mesure du possible, je voudrais documenter la relation en termes plus spécifiques, par exemple. diamants, triangles, etc. Si je ne connais pas la relation exacte, mon point de départ est une ligne continue avec des flèches (une association, une dépendance (implicite)).

Malgré cela, la notation en pointillé peut être utile dans d’autres aspects de la modélisation UML, par exemple. montrer les dépendances aux exigences dans l'analyse de cas d'utilisation, par exemple. NOTE La Thought Police voudrait réduire le couplage et les dépendances entre les classes en utilisant des interfaces (classes virtuelles pures) autant que possible.

Tandis que les classes virtuelles pures offrent la perspective d'un héritage multiple et du couplage le plus étroit possible entre toutes les classes. Les classes d'interface ont l'avantage d'être entièrement faites de matière noire et donc totalement invisibles pour la police. En gardant cela à l'esprit, il est possible d'écrire du code c ++ avec un couplage apparemment nul entre les classes - ce qu'ils aiment, car ils n'ont jamais vraiment compris tous ces symboles drôles.

5
ANC

D'accord, puisque vous n'avez pas accepté la première réponse. Laisse-moi essayer.

Flèche 1: Une association normale

enter image description here

UML a différents types de lignes et de flèches. Ci-dessus figure la simple flèche d’association, ce qui signifie qu’une classe peut avoir un lien avec l’autre classe. Ci-dessous, je vais expliquer chaque type AVEC des exemples de code.

  • Dans le premier exemple, vous pouvez voir qu'il n'y a pas vraiment spécifié qui sait qui (qui est le propriétaire de la relation). Un animal peut connaître l'homme et l'homme peut connaître l'animal. Ce n'est pas spécifié et donc pas vraiment utile pour le programmeur.
  • Dans le deuxième exemple, l’artiste peut possède une guitare. Parce qu'il y a une flèche et qu'il n'y en a pas de l'autre côté, nous savons que la guitare ne sait pas l'artiste. Une guitare est un objet qui peut totalement exister par lui-même et n’a besoin de personne.
  • Dans le troisième exemple, vous voyez un mariage. Vraiment simple; le mari connaît la femme et la femme connaît son mari. Dans notre cas, le mari n'a qu'une femme et vice versa.

Comment pouvons-nous accomplir cela généralement dans le code?

class Husband{
    Wife bestWomanInTheWorld;

    public Husband(Wife theWife){
        this.bestWomanInTheWorld = theWife;
    }
}

Parce que le mari toujours a besoin d'une femme, nous mettons la relation obligatoire dans le constructeur. Parce qu'un artiste peut a une guitare, nous laisserions le constructeur vide comme ceci:

class Artist{
    List<Guitar> guitars;

    public Artist(){
    }

    public AddGuitarToCollection(Guitar newGuitar){
        Guitars.Add(newGuitar);
    }
}

Donc, c'est comme ça que nous accomplissons cela dans le code (la plupart du temps!). Si vous débutez en programmation, vous n’avez généralement pas besoin de différents types de lignes et de flèches. Rester simple.

Flèche 2: Dépendance

Bon, nous connaissons donc les associations normales que nous utiliserons la plupart du temps. Mais quand utiliserons-nous la flèche "dépendance"? Eh bien, définissons une dépendance (wikipedia):

Dependency is a weaker form of bond which indicates that one class depends on 
another because it uses it at some point in time. One class depends on 
another if the independent class is a parameter variable or local variable of 
a method of the dependent class. This is different from an association, where 
an attribute of the dependent class is an instance of the independent class. 
Sometimes the relationship between two classes is very weak. They are not 
implemented with member variables at all. Rather they might be implemented as 
member function arguments.

S'il existe un lien, une relation, une association, etc. qui nécessite d'être présent, la classe doit fonctionner; c'est une dépendance. Exemple: Mari a besoin la femme doit exister. Une voiture a besoin une roue pour être une voiture (et conduire). Une usine de voitures a besoin une classe de voitures pour en faire un objet. Votre classe RSSNewsItem nécessite une classe XMLReader pour tout faire.

Quand utiliser lequel?

Eh bien, c’est la seule question valable à mes yeux; depuis Google montre beaucoup de réponses valides à votre question. Essayez de ne jamais utiliser une dépendance dans un diagramme de classes car cela signifie généralement que vous n'êtes pas assez spécifique. Visez toujours les associations, les réalisations, etc. N'utilisez les réalisations (à mon avis) que s'il est nécessaire d'utiliser une autre classe sans maintenir de relation. Exemple; Classes utilitaires (comme XMLReader).

Si vous avez des questions après avoir lu cette explication complète, n'hésitez pas à demander. : -)

5
zondvloed

Votre question m'a donné une bonne chance d'apprendre moi-même, voici ce que j'ai trouvé -

enter image description here

Association : propriété d'un autre type (par exemple, "A" possède un "B")

//@assoc  The Player(A) has some Dice(B)
class Player {
    Dice myDice;
}

Dépendance : Utilisation d’un autre type (par exemple, "C" utilise un "D")

//@dep    The Player(C) uses some Dice(D) when playing a game
class Player {
    rollYahtzee(Dice someDice);
}

Voici une référence précise que j'ai trouvée - Association vs. Dependency

3
J-Dizzle