UML and Design Patterns

Posted on February 2, 2022
Tags: softdev

1 Basics

1.1 Concrete Class Inheritance

classDiagram classA <|-- classB : Inherits

1.2 Interface implementation

classDiagram IclassA <|.. classB : Implements

1.3 Association: Composition vs Aggregation

Composition and Aggregation are both Associations.
\[ Composition \subset Association \qquad Aggregation \subset Association\]

Composition is stronger than Aggregation

  • Composition: A “Owns” B ; B has no meaning without A
  • Aggregation: A “Uses” B ; B can exist independently from A
classDiagram classC --* classD : Composition classE --o classF : Aggregation

2 Interface

\[ Implemented(ICar) = \{Honda, Toyota, Tesla\}\] \[ Methods(ICar) \subset Methods(Honda)\] \[ \forall X : X\ DependOn ICar \Rightarrow X\ CanDependOn \{Honda, Toyota, Tesla\}\]

classDiagram IclassA <|-- classB : Implements classC --* classD : Composition classE --o classF : Aggregation classG --> classH : Association classI -- classJ : Link(Solid) classK ..> classL : Dependency classM ..|> classN : Realization classO .. classP : Link(Dashed)
classDiagram class Honda{ +drive() +Loud Honk() } class Toyota{ +drive() +Quiet Honk() } class Tesla{ +drive() +autopilot() } class ICar{ +drive() } Honda ..|> ICar Toyota ..|> ICar Tesla ..|> ICar X ..> ICar X ..> Tesla

3 Class vs Interface

Compared to normal UML, we reversed the arrow for the Interface-Class relation.


     Class       Vs  Interface

  ┌─────────────┐   ┌──────────────┐
  │             │   │              │
  │  Dog Class  │   │Dog Interface │
  │   ▲         │   │      │       │
  │   │         │   │              │
  │   │         │   │      │       │
  │   │         │   │              │
  │   │         │   │      │       │
  │   │         │   │      ▼       │
  │GreyHound    │   │ GreyHound    │
  │  Class      │   │    Class     │
  │             │   │              │
  └─────────────┘   └──────────────┘

4 Design patterns

4.1 Factory

classDiagram class AbstractFactoryClass{ +ABSTRACT createIButton() +CONCRETE render() } AbstractFactoryClass ..> IButton : Factory Method AbstractFactoryClass <|-- ConcreteFactory_Windows : extends AbstractFactoryClass <|-- ConcreteFactory_Mac : extends ConcreteButton_Windows <|.. IButton : implements ConcreteButton_Mac <|.. IButton : implements
AbstractFactoryClass obj;
if (options == "Windows"){
  obj = New ConcreteFactory_Windows();
}else 
if (options == "Mac"){
  obj = New ConcreteFactory_Mac();
}
IButton mybutton = obj.createIButton(); //createIButton() is the factoryMethod
  • Factory is Abstract Class/Interface that is USED FOR
    • different Factory creation via Abstract Class obj = New ConcreteFactory_Windows()
  • Factory is Abstract Class/Interface that HAS
    • common method render()
    • different object creation via interface IButton = new ConcreteMacButton()

Factory pattern is like an OOP-switch-builder pattern.