设计模式

@startuml
/'
 ' scale 450 width
 ' skinparam classAttributeIconSize 0
 '/
abstract class Strategy{
+ {abstract} AlgorithmInterface()
}

class Context{
+ ContextInterface()
}

class ConcreteStrategyA{
+ AlgorithmInterface()
}

class ConcreteStrategyB{
+ AlgorithmInterface()
}

Context o- Strategy
Strategy <|-- ConcreteStrategyA
Strategy <|-- ConcreteStrategyB
@enduml

scale 650 width
skinparam classAttributeIconSize 0
abstract class State{
    + {abstract} Handle()
}

class ConcreteStateA{
    + Handle()
}

class ConcreteStateB{
    + Handle()
}

class Context{
    - State state
    + Request()
}

note "state->Handle()" as N1
Context .. N1
Context o- State
note "generally use Singleton" as N2
State . N2
State <|-- ConcreteStateA
State <|-- ConcreteStateB

scale 720 width
skinparam classAttributeIconSize 0
abstract class Subject {
    + {abstract}Attach(observer)
    + {abstract}Detach(observer)
    + Notify()
}

abstract class Observer {
    + {abstract}Update()
}

class ConcreteSubject {
    - subjectState
    + GetState()
    + SetState()
}

class ConcreteObserver {
    - observerState
    + Update()
}

note "In Update():\nobserverState = subject->GetState()" as N1

Subject "1..*" o- Observer
Subject <|.. ConcreteSubject
Observer <|.. ConcreteObserver
ConcreteSubject <- ConcreteObserver
ConcreteObserver . N1

scale 500 width
aConcreteSubject <- aConcreteObserver : SetState()
activate aConcreteSubject

aConcreteSubject <- aConcreteSubject : Notify()
activate aConcreteSubject

aConcreteSubject -> aConcreteObserver : Update()
activate aConcreteObserver
aConcreteSubject <- aConcreteObserver : GetState()
deactivate aConcreteObserver
aConcreteSubject -> anotherConcreteObserver : Update()
activate anotherConcreteObserver
aConcreteSubject <- anotherConcreteObserver : GetState()
deactivate anotherConcreteObserver

deactivate aConcreteSubject
deactivate aConcreteSubject

scale 800 width
skinparam classAttributeIconSize 0
abstract class Subject {
    + {abstract}Attach(observer)
    + {abstract}Detach(observer)
    + Notify()
}

abstract class ChangeManager {
    - SubjectObserverMap
    + {abstract}Register(Subject, Observer)
    + {abstract}Unregister(Subject, Observer)
    + {abstract}Notify()
}

class SimpleChangeManager
class DAGChangeManager

abstract class Observer {
    + {abstract}Update(subject)
}

note "chman->Notify()" as N1
note "foreach s in subjects\n  foreach o in s.objects\n    o->Update(s)" as N2
note "Step1: mark all observers to update\n update all marked observers" as N3

Subject -o "1..*" ChangeManager
Subject "chman" -> ChangeManager
N1 . Subject
ChangeManager "1..*" o- Observer
ChangeManager <|.. SimpleChangeManager
ChangeManager <|.. DAGChangeManager
SimpleChangeManager .. N2
DAGChangeManager .. N3

scale 180 width
skinparam classAttributeIconSize 0
abstract class AbstractClass {
    + TemplateMethod()
    + {abstract} PrimitiveOperation1()
    + {abstract} PrimitiveOperation2()
}

class ConcreteClass {
    + PrimitiveOperation1()
    + PrimitiveOperation2()
}

AbstractClass <|-- ConcreteClass

scale 650 width
skinparam classAttributeIconSize 0
abstract class Component {
    + {abstract} Operation()
}

class ConcreteComponent {
    + Operation()
}

note "optional" as N1
note "component->Operation()" as N2
abstract class Decorator {
    + {abstract} Operation()
}

class ConcreteDecoratorA {
    + addedState
    + Operation()
}

class ConcreteDecoratorB {
    + Operation()
    + AddedBehavior()
}

Component <|-- ConcreteComponent
Component <|-- Decorator
Decorator <|-- ConcreteDecoratorA
Decorator <|-- ConcreteDecoratorB
N1 .. Decorator
Decorator . N2

scale 200 width
skinparam classAttributeIconSize 0
class Singleton {
    - {static} Singleton uniqueInstance
    - Singleton()
    - ~Singleton()
    + {static} Singleton GetInstance()
    + SingletonOperation()
}

class Singleton
{
public:
    static Singleton* GetInstance();
protected:
    Singleton() : _instance(NULL);//隐藏的构造函数
private:
    static Singleton* _instance;
};

Singleton* Singleton::GetInstance ()
{
    if (_instance == NULL) _instance = new Singleton;
    return _instance;
}

scale 550 width
skinparam classAttributeIconSize 0
class Client
class Invoker
class Receiver{
    + Action()
}
abstract class Command{
    + {abstract} Execute()
    + {abstract} Undo()
}
class ConcreteCommand{
    + Execute()
    + Undo()
    - state
}

note right of ConcreteCommand
receiver->Action();
end note

Client --> Receiver
Receiver <- "receiver" ConcreteCommand
Client ..> ConcreteCommand
Command <|-- ConcreteCommand
Command -o Invoker

scale 520 width
skinparam classAttributeIconSize 0
class Client
abstract class Subject{
    + {abstract} Request()
}
class RealSubject{
    + Request()
}
class Proxy{
    + Request()
}

note right of Proxy
realSubject->Request();
. . .
end note


Client -> Subject
Subject <|-- RealSubject
Subject <|-- Proxy
RealSubject <- Proxy

scale 450 width
title <b>Facade Pattern</b>
package Package <<Folder>> {
    class Facade
    class Class1
    class Class2
    class Class3
    Facade ..> Class1
    Facade ..> Class2
    Facade ..> Class3
}

class Client
Client ..> Facade

scale 500 width
skinparam classAttributeIconSize 0
class Client
abstract class Aggregate{
    + {abstract} Iterator CreateIterator()
}
abstract class Iterator{
    + {abstract} First()
    + {abstract} Next()
    + {abstract} IsDone()
    + {abstract} CurrentItem()
}

class ConcreteAggregate{
    + Iterator CreateIterator()
}

class ConcreteIterator

note "return new ConcreteIterator(this)" as N1

Client -> Iterator
Aggregate <- Client
Aggregate <|-- ConcreteAggregate
Iterator <|-- ConcreteIterator
ConcreteAggregate .> ConcreteIterator
ConcreteAggregate <- ConcreteIterator
ConcreteAggregate .. N1

scale 800 width
skinparam classAttributeIconSize 0

class Client
abstract class Abstraction {
    + Operation()
}
class RefinedAbstraction
abstract class Implementor {
    + {abstract} OperationImp()
}
class ConcreteImplementorA {
    + OperationImp()
}
class ConcreteImplementorB {
    + OperationImp()
}


note "imp->OperationImp()" as N1

Client --> Abstraction
Abstraction <|-- RefinedAbstraction
N1 . Abstraction
Abstraction o- Implementor
Implementor <|-- ConcreteImplementorA
Implementor <|-- ConcreteImplementorB

scale 450 width
skinparam classAttributeIconSize 0
class Director {
    + Construct()
}

abstract class Builder {
    + {abstract} BuildPartA()
    + {abstract} BuildPartB()
}

class ConcreteBuilder {
    + BuildPartA()
    + BuildPartB()
    + GetResult()
}

class Product

Director o- Builder
Builder <|-- ConcreteBuilder
ConcreteBuilder .> Product

scale 340 width
activate aClient
aClient --> aDirector : new()
activate aDirector
deactivate aDirector
aClient --> aConcreteBuilder : new()
activate aConcreteBuilder
deactivate aConcreteBuilder
aClient -> aDirector : Construct()
activate aDirector
aDirector -> aConcreteBuilder : BuildPartA()
activate aConcreteBuilder
deactivate aConcreteBuilder
aDirector -> aConcreteBuilder : BuildPartB()
activate aConcreteBuilder
deactivate aConcreteBuilder
aDirector -> aConcreteBuilder : BuildPartC()
activate aConcreteBuilder
deactivate aConcreteBuilder
deactivate aDirector
aClient -> aConcreteBuilder : GetResult()
activate aConcreteBuilder
deactivate aConcreteBuilder
deactivate aClient

scale 400 width
skinparam classAttributeIconSize 0

class Client
abstract class Component {
    + {abstract}Operation()
    + Add(Component)
    + Remove(Component)
    + GetChild(int)
}

class Leaf {
    + Operation()
}

class Composite {
    + Operation()
    + Add(Component)
    + Remove(Component)
    + GetChild(int)
}

Note "forall c in children\n    c.Operation();" as N1

Client -> Component

Component <|-- Leaf
Component <|-- Composite
Composite .. N1
Component --o "children" Composite

scale 400 width
skinparam classAttributeIconSize 0

class Client

abstract class Handler {
    + {abstract} HandleRequest()
}

class ConcreteHandler1 {
    + HandleRequest()
}

class ConcreteHandler2 {
    + HandleRequest()
}

Client -> Handler
Handler <|-- ConcreteHandler1
Handler <|-- ConcreteHandler2
Handler -> "next" Handler

class Object
{
public:
    vitual void DoSomething() = 0;
};

class NullObject : public Object
{
public:
    void DoSomething();
};

void NullObject::DoSomething()
{
    //do nothing
}