Разделение абстрактного/конкретного класса на диаграмме последовательности

Question

Есть ли способ отделить абстрактный класс и конкретные ветви на диаграмме последовательности?

Моим вариантом использования является то, что некоторые транзакции должны использовать методы, реализованные в абстрактном классе, а некоторые - из его конкретных реализаций.

Или это проблема диаграммы классов, а не диаграммы последовательности?

Answer 1

На диаграмме последовательности вы должны использовать объекты тех типов, которые, как вы знаете, должны находиться в этой конкретной точке выполнения.

Затем вы вызываете метод на этом объекте, даже если это метод, реализованный в абстрактном родительском классе.

Последовательные диаграммы очень похожи на код int hat respect.

Так предположим, что вы следующие ситуации:

Затем вызывается как реализована в виде абстрактной операции на предмет ConcreteSubClass, потому что ваш пользовательский класс имеет ассоциацию с ConcreteSubClass, независимо от того, где операция выполнена.

Если пользователя класс имел ассоциацию к AbstractClass тогда вы называете операции на объект типа AbstractClass

Answer 2

Если вы хотите модель два различных класса то на диаграмме последовательности это означало бы две различные линии жизни. Это все (насколько я знаю).

Вы можете показать любой <<stereotype>> (включая <<abstract>>) в голове спасательной как в этом примере: uml-diagrams.org: UML Sequence Diagrams Examples → Submit Comments to Pluck

Для примера, давайте предположим, что мы имеем это (бесполезные) C# код:

abstract class BaseClass 
{ 
    protected abstract string Name { get; } 

    public virtual void DoSomething() 
    { 
     Console.WriteLine("Something useful done."); 
    } 

    protected void SayHello(string to) 
    { 
     Console.WriteLine("Hi {0}, I'm {1}", to, this.Name); 
    } 
} 

class Case1 : BaseClass 
{ 
    protected override string Name { get { return "Case 1"; } } 

    public override void DoSomething() 
    { 
     base.DoSomething(); 
    } 
} 

class Case2 : BaseClass 
{ 
    protected override string Name { get { return "Case 2"; } } 

    public void DoSomething(string to) 
    { 
     this.SayHello(to); 
     base.DoSomething(); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var c1 = new Case1(); 
     var c2 = new Case2(); 
     c1.DoSomething(); 
     c2.DoSomething("Jane"); 
    } 
} 

Тогда UML Диаграмма последовательности захвата, что происходит жгутов в Program.Main может выглядеть следующим образом:

Я нарисовал абстрактный класс как неявный объект-друга, разделяющий время жизни (и большую часть памяти) с конкретным экземпляром класса. На самом деле, как наследование классов реализовано на некоторых языках, поэтому сценарий не полностью «составлен».

Однако уровень детализации может быть слишком сосредоточен на реализации, не оставляя места для полезной абстракции. Эта диаграмма не сохранилась бы даже при небольшом повторном факторинг кода