1
classDiagram
2
  Button --|> List
3
  Button --|> ComboBox
4
  List -- TextBox
5
  Button --|> Label
6
  List -- ComboBox
7
  Button --|> TextBox
8
  TextBox -- ComboBox

1
classDiagram
2
  Medidator --|> Button
3
  Medidator --|> List
4
  Medidator --|> ComboBox
5
  Medidator --|> Label
6
  Medidator --|> TextBox

1
public class SingletonExample {
2
  //private 避免类在外部被实例化
3
  private SingletonExample() {
4
  }
5
  private static SingletonExample _instance = new SingletonExample();
6
  public static SingletonExample getInstance() {
7
    return _instance;
8
  }
9
}

1
public class SingletonExample {
2
  private SingletonExample() {
3
  }
4
  private static SingletonExample _instance;
5
  public static SingletonExample getInstance() {
6
    if (_instance==null) {
7
      _instance = new SingletonExample();
8
    }
9
    return _instance;
10
  }
11
}

1
public class SingletonExample {
2
  private SingletonExample() {
3
  }
4
  private static volatile SingletonExample _instance = null;    //保证instance在所有线程中同步
5
  public static synchronized SingletonExample getInstance() {
6
    //getInstance 方法前加同步
7
    if (_instance == null) {
8
      _instance = new SingletonExample();
9
    }
10
    return _instance;
11
  }
12
}

1
public class SingletonExample {
2
  private SingletonExample() {
3
  }
4
  private volatile static SingletonExample _instance;
5
  public static SingletonExample getInstance() {
6
    if (_instance==null) {
7
      synchronized (SingletonExample.class) {
8
        if (_instance==null) {
9
          _instance = new SingletonExample();
10
        }
11
      }
12
    }
13
    return _instance;
14
  }
15
}

1
class Product {
2
  void use() {
3
    System.out.println("Using a product");
4
  }
5
}
6

7
class ConcreteProductA extends Product {
8
  void use() {
9
    System.out.println("Using Product A");
10
  }
11
}
12

13
class ConcreteProductB extends Product {
14
  void use() {
15
    System.out.println("Using Product B");
16
  }
17
}
18

19
class SimpleFactory {
20
  static Product createProduct(String type) {
21
    return switch (type) {
22
      case "A" -> new ConcreteProductA();
23
      case "B" -> new ConcreteProductB();
24
      default -> throw new IllegalArgumentException("Unknown type");
25
    };
26
  }
27
}
28

29
public class Main {
30
  public static void main(String[] args) {
31
    Product product = SimpleFactory.createProduct("A");
32
    product.use();
33
  }
34
}

1
class Box implements Cloneable {
2
  private ArrayList<String> items = new ArrayList<String>();
3
  public Box() {
4
  }
5
  public void addItem(String item) {
6
    items.add(item);
7
  }
8
  @Override
9
  protected Box clone() throws CloneNotSupportedException {
10
    return (Box) super.clone();
11
  }
12
  @Override
13
  public String toString() {
14
    return String.format("盒子(@%s)[物件列表(@%s)%s]",Integer.toHexString(this.hashCode()),Integer.toHexString(items.hashCode()),items.toString());
15
  }
16
}

1
public static void main(String[] args) throws Exception {
2
  Box box1 = new Box();
3
  box1.addItem("物件1");
4
  Box box2 = box1.clone();
5
  System.out.println(box1);
6
  System.out.println(box2);
7
  /*结果：
8
  盒子(@4926097b)[物件列表(@1b70c43)[物件1]]
9
  盒子(@19dfb72a)[物件列表(@1b70c43)[物件1]]
10
  */
11
}

1
@Override
2
protected Box clone() throws CloneNotSupportedException {
3
  Box clone = (Box) super.clone();
4
  //items也需要克隆
5
  clone.items = (ArrayList<String>) this.items.clone();
6
  return clone;
7
}

1
public static void main(String[] args) throws Exception {
2
  Box box1 = new Box();
3
  box1.addItem("物件1");
4
  Box box2 = box1.clone();
5
  box1.addItem("物件2");
6
  System.out.println(box1);
7
  System.out.println(box2);
8
  /*结果：
9
  盒子(@4926097b)[物件列表(@36e18842)[物件1, 物件2]]
10
  盒子(@19dfb72a)[物件列表(@1b70c43)[物件1]]
11
  */
12
}

1
// 目标接口
2
interface Target {
3
  void request();
4
}
5

6
// 需要适配的类
7
class Adaptee {
8
  void specificRequest() {
9
    System.out.println("Specific request.");
10
  }
11
}
12

13
// 适配器类
14
class Adapter implements Target {
15
  private Adaptee adaptee;
16

17
  public Adapter(Adaptee adaptee) {
18
    this.adaptee = adaptee;
19
  }
20

21
  @Override
22
  public void request() {
23
    adaptee.specificRequest();  // 调用被适配类的方法
24
  }
25
}
26

27
// 客户端代码
28
public class AdapterPatternExample {
29
  public static void main(String[] args) {
30
    Adaptee adaptee = new Adaptee();
31
    Target target = new Adapter(adaptee);
32
    target.request();  // 输出：Specific request.
33
  }
34
}

1
// 组件接口
2
interface Component {
3
  void operation();
4
}
5

6
// 叶子节点类
7
class Leaf implements Component {
8
  @Override
9
  public void operation() {
10
    System.out.println("Leaf operation.");
11
  }
12
}
13

14
// 组合节点类
15
class Composite implements Component {
16
  private List<Component> children = new ArrayList<>();
17

18
  public void add(Component component) {
19
    children.add(component);
20
  }
21

22
  public void remove(Component component) {
23
    children.remove(component);
24
  }
25

26
  @Override
27
  public void operation() {
28
    for (Component child : children) {
29
      child.operation();
30
    }
31
  }
32
}
33

34
// 客户端代码
35
public class CompositePatternExample {
36
  public static void main(String[] args) {
37
    Leaf leaf1 = new Leaf();
38
    Leaf leaf2 = new Leaf();
39

40
    Composite composite = new Composite();
41
    composite.add(leaf1);
42
    composite.add(leaf2);
43

44
    composite.operation();  // 输出：Leaf operation. Leaf operation.
45
  }
46
}

1
// 基础接口
2
interface Coffee {
3
  double cost();
4
}
5

6
// 基础类
7
class SimpleCoffee implements Coffee {
8
  @Override
9
  public double cost() {
10
    return 5;
11
  }
12
}
13

14
// 装饰器抽象类
15
abstract class CoffeeDecorator implements Coffee {
16
  protected Coffee decoratedCoffee;
17

18
  public CoffeeDecorator(Coffee coffee) {
19
    this.decoratedCoffee = coffee;
20
  }
21

22
  @Override
23
  public double cost() {
24
    return decoratedCoffee.cost();
25
  }
26
}
27

28
// 具体装饰器
29
class MilkDecorator extends CoffeeDecorator {
30
  public MilkDecorator(Coffee coffee) {
31
    super(coffee);
32
  }
33

34
  @Override
35
  public double cost() {
36
    return decoratedCoffee.cost() + 2;
37
  }
38
}
39

40
class SugarDecorator extends CoffeeDecorator {
41
  public SugarDecorator(Coffee coffee) {
42
    super(coffee);
43
  }
44

45
  @Override
46
  public double cost() {
47
    return decoratedCoffee.cost() + 1;
48
  }
49
}
50

51
// 客户端代码
52
public class DecoratorPatternExample {
53
  public static void main(String[] args) {
54
    Coffee coffee = new SimpleCoffee();
55
    System.out.println("Cost of simple coffee: " + coffee.cost());
56

57
    coffee = new MilkDecorator(coffee);  // 加奶
58
    System.out.println("Cost of coffee with milk: " + coffee.cost());
59

60
    coffee = new SugarDecorator(coffee);  // 加糖
61
    System.out.println("Cost of coffee with milk and sugar: " + coffee.cost());
62
  }
63
}

1
classDiagram
2
  接口 <|.. 实现类
3
  接口 <|.. 代理类
4
  代理类 <-- Client
5
  实现类 <-- 代理类
6
  class 接口{
7
     <<interface>>
8
   }

1
// 接口
2
interface A {
3
  public void f();
4
}
5
// 实现类
6
class AImpl implements A {
7
  public void f() {
8
    System.out.println("A.f()");
9
  }
10
}
11
// 代理类
12
class AProxy implements A {
13
  A a;
14
  public AProxy(A a) {
15
    this.a = a;
16
  }
17
  public void f() {
18
    // do something else
19
    a.f();
20
    // do something else
21
  }
22
}
23
// Client
24
public static void main() {
25
  A aImpl = new AImpl();
26
  AProxy aProxy = new AProxy(aImpl);
27
  aProxy.f();
28
}

1
graph RL
2
Client --> P["Proxy实现类<br>Proxy(InvocationHandler)"] --> I["InvocationHandler实现类<br>实现类的引用<br>invoke"] --> 实现类
3
P & 实现类 --> interface["<interface>"]
4
Ptips["这个Proxy实现类是<br>由Proxy的static方法在执行时刻生成的<br>这个类和被代理类有相同的接口<br>并且它的构造函数的参数是InvocaHandler。<br>因为这个类是在运行时刻生成的<br>可以根据传入不同的参数生成不同的代理类<br>所以是动态代理。"] -.-> P

1
// InvocationHandler实现类，里面有一个object对象，指向真正的实现类
2
InvocationHandler handler = new MyInvocationHandler();
3
// 代理类，是有Proxy生成的，根据这点代码，已知的是，它实现了被代理类的接口，而且它有个参数为InvocationHandler作为参数的构造函数
4
Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
5
Foo f = (Foo)proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);

1
Foo f = (Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class<?>[]{Foo.class}, handler);

1
// 内享状态类
2
class Flyweight {
3
  private String intrinsicState;  // 内享状态
4

5
  public Flyweight(String state) {
6
    this.intrinsicState = state;
7
  }
8

9
  public void operation(String extrinsicState) {
10
    System.out.println("Intrinsic: " + intrinsicState + ", Extrinsic: " + extrinsicState);
11
  }
12
}
13

14
// 亨元工厂类
15
class FlyweightFactory {
16
  private Map<String, Flyweight> flyweights = new HashMap<>();
17

18
  public Flyweight getFlyweight(String key) {
19
    if (!flyweights.containsKey(key)) {
20
      flyweights.put(key, new Flyweight(key));
21
    }
22
    return flyweights.get(key);
23
  }
24
}
25

26
// 客户端代码
27
public class FlyweightPatternDemo {
28
  public static void main(String[] args) {
29
    FlyweightFactory factory = new FlyweightFactory();
30
    Flyweight flyweight1 = factory.getFlyweight("A");
31
    flyweight1.operation("1");
32
    Flyweight flyweight2 = factory.getFlyweight("B");
33
    flyweight2.operation("2");
34
  }
35
}

1
// 子系统A
2
class SubsystemA {
3
  public void operationA() {
4
    System.out.println("Subsystem A Operation");
5
  }
6
}
7

8
// 子系统B
9
class SubsystemB {
10
  public void operationB() {
11
    System.out.println("Subsystem B Operation");
12
  }
13
}
14

15
// 子系统C
16
class SubsystemC {
17
  public void operationC() {
18
    System.out.println("Subsystem C Operation");
19
  }
20
}
21

22
// 外观类
23
class Facade {
24
  private SubsystemA subsystemA;
25
  private SubsystemB subsystemB;
26
  private SubsystemC subsystemC;
27

28
  public Facade() {
29
    this.subsystemA = new SubsystemA();
30
    this.subsystemB = new SubsystemB();
31
    this.subsystemC = new SubsystemC();
32
  }
33

34
  public void operation() {
35
    subsystemA.operationA();
36
    subsystemB.operationB();
37
    subsystemC.operationC();
38
  }
39
}
40

41
// 客户端代码
42
public class FacadePatternDemo {
43
  public static void main(String[] args) {
44
    Facade facade = new Facade();
45
    facade.operation();
46
  }
47
}

1
// 抽象化角色
2
abstract class Shape {
3
  protected DrawAPI drawAPI;
4

5
  protected Shape(DrawAPI drawAPI){
6
    this.drawAPI = drawAPI;
7
  }
8

9
  public abstract void draw();
10
}
11

12
// 具体抽象化角色
13
class Circle extends Shape {
14
  private int x, y, radius;
15

16
  public Circle(int x, int y, int radius, DrawAPI drawAPI) {
17
    super(drawAPI);
18
    this.x = x;
19
    this.y = y;
20
    this.radius = radius;
21
  }
22

23
  @Override
24
  public void draw() {
25
    drawAPI.drawCircle(x, y, radius);
26
  }
27
}
28

29
// 实现化角色
30
interface DrawAPI {
31
  void drawCircle(int x, int y, int radius);
32
}
33

34
// 具体实现化角色
35
class RedCircle implements DrawAPI {
36
  @Override
37
  public void drawCircle(int x, int y, int radius) {
38
    System.out.println("Drawing Circle[ color: red, x: " + x + ", y: " + y + ", radius: " + radius + "]");
39
  }
40
}
41

42
class GreenCircle implements DrawAPI {
43
  @Override
44
  public void drawCircle(int x, int y, int radius) {
45
    System.out.println("Drawing Circle[ color: green, x: " + x + ", y: " + y + ", radius: " + radius + "]");
46
  }
47
}
48

49
// 客户端代码
50
public class BridgePatternExample {
51
  public static void main(String[] args) {
52
    Shape redCircle = new Circle(100, 100, 10, new RedCircle());
53
    Shape greenCircle = new Circle(200, 200, 20, new GreenCircle());
54

55
    redCircle.draw();
56
    greenCircle.draw();
57
  }
58
}

1
// 抽象类定义模板方法
2
abstract class DataProcessor {
3
  // 模板方法，定义了处理流程
4
  public final void processData() {
5
    loadData();
6
    parseData();
7
    processData();
8
    saveData();
9
  }
10

11
  // 具体方法，子类不需要实现
12
  private void loadData() {
13
    System.out.println("Loading data...");
14
  }
15

16
  // 抽象方法，子类必须实现
17
  protected abstract void parseData();
18

19
  // 抽象方法，子类必须实现
20
  protected abstract void processData();
21

22
  // 具体方法，子类不需要实现
23
  private void saveData() {
24
    System.out.println("Saving data...");
25
  }
26
}
27

28
// 具体类实现具体步骤
29
class CSVDataProcessor extends DataProcessor {
30
  @Override
31
  protected void parseData() {
32
    System.out.println("Parsing CSV data...");
33
  }
34

35
  @Override
36
  protected void processData() {
37
    System.out.println("Processing CSV data...");
38
  }
39
}
40

41
class JSONDataProcessor extends DataProcessor {
42
  @Override
43
  protected void parseData() {
44
    System.out.println("Parsing JSON data...");
45
  }
46

47
  @Override
48
  protected void processData() {
49
    System.out.println("Processing JSON data...");
50
  }
51
}
52

53
// 客户端代码
54
public class TemplateMethodExample {
55
  public static void main(String[] args) {
56
    DataProcessor csvProcessor = new CSVDataProcessor();
57
    DataProcessor jsonProcessor = new JSONDataProcessor();
58

59
    System.out.println("Processing CSV data:");
60
    csvProcessor.processData();
61

62
    System.out.println("\nProcessing JSON data:");
63
    jsonProcessor.processData();
64
  }
65
}

1
// 抽象表达式
2
interface Expression {
3
  int interpret();
4
}
5

6
// 终结符表达式
7
class Number implements Expression {
8
  private int number;
9

10
  public Number(int number) {
11
    this.number = number;
12
  }
13

14
  @Override
15
  public int interpret() {
16
    return this.number;
17
  }
18
}
19

20
// 非终结符表达式
21
class Add implements Expression {
22
  private Expression leftExpression;
23
  private Expression rightExpression;
24

25
  public Add(Expression leftExpression, Expression rightExpression) {
26
    this.leftExpression = leftExpression;
27
    this.rightExpression = rightExpression;
28
  }
29

30
  @Override
31
  public int interpret() {
32
    return this.leftExpression.interpret() + this.rightExpression.interpret();
33
  }
34
}
35

36
// 上下文
37
class InterpreterContext {
38
  public static void main(String[] args) {
39
    Expression expression = new Add(new Number(5), new Number(10));
40
    System.out.println("结果: " + expression.interpret());
41
  }
42
}

1
// 策略接口
2
interface Strategy {
3
  int doOperation(int num1, int num2);
4
}
5

6
// 具体策略
7
class OperationAdd implements Strategy {
8
  @Override
9
  public int doOperation(int num1, int num2) {
10
    return num1 + num2;
11
  }
12
}
13

14
class OperationSubtract implements Strategy {
15
  @Override
16
  public int doOperation(int num1, int num2) {
17
    return num1 - num2;
18
  }
19
}
20

21
class OperationMultiply implements Strategy {
22
  @Override
23
  public int doOperation(int num1, int num2) {
24
    return num1 * num2;
25
  }
26
}
27

28
// 上下文
29
class Context {
30
  private Strategy strategy;
31

32
  public Context(Strategy strategy) {
33
    this.strategy = strategy;
34
  }
35

36
  public int executeStrategy(int num1, int num2) {
37
    return strategy.doOperation(num1, num2);
38
  }
39
}
40

41
public class StrategyPatternDemo {
42
  public static void main(String[] args) {
43
    Context context = new Context(new OperationAdd());
44
    System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
45

46
    context = new Context(new OperationSubtract());
47
    System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
48

49
    context = new Context(new OperationMultiply());
50
    System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
51
  }
52
}

1
// 状态接口
2
interface State {
3
  void doAction(Context context);
4
}
5

6
// 具体状态
7
class StartState implements State {
8
  @Override
9
  public void doAction(Context context) {
10
    System.out.println("玩家处于开始状态");
11
    context.setState(this);
12
  }
13

14
  @Override
15
  public String toString() {
16
    return "开始状态";
17
  }
18
}
19

20
class StopState implements State {
21
  @Override
22
  public void doAction(Context context) {
23
    System.out.println("玩家处于停止状态");
24
    context.setState(this);
25
  }
26

27
  @Override
28
  public String toString() {
29
    return "停止状态";
30
  }
31
}
32

33
// 上下文
34
class Context {
35
  private State state;
36

37
  public Context() {
38
    state = null;
39
  }
40

41
  public void setState(State state) {
42
    this.state = state;
43
  }
44

45
  public State getState() {
46
    return state;
47
  }
48
}
49

50
public class StatePatternDemo {
51
  public static void main(String[] args) {
52
    Context context = new Context();
53

54
    StartState startState = new StartState();
55
    startState.doAction(context);
56
    System.out.println("当前状态: " + context.getState().toString());
57

58
    StopState stopState = new StopState();
59
    stopState.doAction(context);
60
    System.out.println("当前状态: " + context.getState().toString());
61
  }
62
}

1
import java.util.ArrayList;
2
import java.util.List;
3

4
// 主题接口
5
interface Subject {
6
  void registerObserver(Observer o);
7
  void removeObserver(Observer o);
8
  void notifyObservers();
9
}
10

11
// 具体主题
12
class ConcreteSubject implements Subject {
13
  private List<Observer> observers;
14
  private int state;
15

16
  public ConcreteSubject() {
17
    observers = new ArrayList<>();
18
  }
19

20
  public int getState() {
21
    return state;
22
  }
23

24
  public void setState(int state) {
25
    this.state = state;
26
    notifyObservers();
27
  }
28

29
  @Override
30
  public void registerObserver(Observer o) {
31
    observers.add(o);
32
  }
33

34
  @Override
35
  public void removeObserver(Observer o) {
36
    observers.remove(o);
37
  }
38

39
  @Override
40
  public void notifyObservers() {
41
    for (Observer observer : observers) {
42
      observer.update();
43
    }
44
  }
45
}
46

47
// 观察者接口
48
interface Observer {
49
  void update();
50
}
51

52
// 具体观察者
53
class ConcreteObserver implements Observer {
54
  private ConcreteSubject subject;
55

56
  public ConcreteObserver(ConcreteSubject subject) {
57
    this.subject = subject;
58
    this.subject.registerObserver(this);
59
  }
60

61
  @Override
62
  public void update() {
63
    System.out.println("观察者收到更新: " + subject.getState());
64
  }
65
}
66

67
public class ObserverPatternDemo {
68
  public static void main(String[] args) {
69
    ConcreteSubject subject = new ConcreteSubject();
70

71
    new ConcreteObserver(subject);
72
    new ConcreteObserver(subject);
73

74
    System.out.println("第一次状态变化: 15");
75
    subject.setState(15);
76

77
    System.out.println("第二次状态变化: 10");
78
    subject.setState(10);
79
  }
80
}

1
// 备忘录
2
class Memento {
3
  private String state;
4

5
  public Memento(String state) {
6
    this.state = state;
7
  }
8

9
  public String getState() {
10
    return state;
11
  }
12
}
13

14
// 原发器
15
class Originator {
16
  private String state;
17

18
  public void setState(String state) {
19
    this.state = state;
20
  }
21

22
  public String getState() {
23
    return state;
24
  }
25

26
  public Memento saveStateToMemento() {
27
    return new Memento(state);
28
  }
29

30
  public void getStateFromMemento(Memento memento) {
31
    state = memento.getState();
32
  }
33
}
34

35
// 负责人
36
class Caretaker {
37
  private List<Memento> mementoList = new ArrayList<>();
38

39
  public void add(Memento state) {
40
    mementoList.add(state);
41
  }
42

43
  public Memento get(int index) {
44
    return mementoList.get(index);
45
  }
46
}
47

48
public class MementoPatternDemo {
49
  public static void main(String[] args) {
50
    Originator originator = new Originator();
51
    Caretaker caretaker = new Caretaker();
52

53
    originator.setState("State #1");
54
    originator.setState("State #2");
55
    caretaker.add(originator.saveStateToMemento());
56

57
    originator.setState("State #3");
58
    caretaker.add(originator.saveStateToMemento());
59

60
    originator.setState("State #4");
61
    System.out.println("当前状态: " + originator.getState());
62

63
    originator.getStateFromMemento(caretaker.get(0));
64
    System.out.println("第一次保存的状态: " + originator.getState());
65
    originator.getStateFromMemento(caretaker.get(1));
66
    System.out.println("第二次保存的状态: " + originator.getState());
67
  }
68
}