Java 和 Kotlin 实现 23 种设计模式：从理论到实践

设计模式是软件开发中办理常见问题的经典办理方案模板。它们帮助开发者编写可维护、可扩展和可重用的代码。本文详细介绍了 23 种经典设计模式，包括创建型、结构型和举动型模式，并提供了 Java 和 Kotlin 的完整实现示例。无论你是初学者照旧有履历的开发者，本文都能帮助你深入理解设计模式的核心思想，并将其应用到实际项目中。
Java 和 Kotlin 实现 23 种设计模式

设计模式是软件开发中常见问题的办理方案模板。它们帮助开发者编写可维护、可扩展和可重用的代码。本文将详细介绍 23 种经典设计模式，并提供 Java 和 Kotlin 的实现示例。
1. 创建型模式

1.1 单例模式 (Singleton)

目标: 确保一个类只有一个实例，并提供全局访问点。
Java 实现:

1. public class Singleton {
2.     private static Singleton instance;
4.     private Singleton() {}
6.     public static Singleton getInstance() {
7.         if (instance == null) {
8.             instance = new Singleton();
9.         }
10.         return instance;
11.     }
12. }

复制代码

Kotlin 实现:

1. object Singleton

复制代码

1.2 工厂方法模式 (Factory Method)

目标: 定义一个创建对象的接口，但让子类决定实例化哪个类。
Java 实现:

1. interface Product {
2.     void use();
3. }
5. class ConcreteProduct implements Product {
6.     @Override
7.     public void use() {
8.         System.out.println("Using ConcreteProduct");
9.     }
10. }
12. abstract class Creator {
13.     public abstract Product factoryMethod();
14. }
16. class ConcreteCreator extends Creator {
17.     @Override
18.     public Product factoryMethod() {
19.         return new ConcreteProduct();
20.     }
21. }

复制代码

Kotlin 实现:

1. interface Product {
2.     fun use()
3. }
5. class ConcreteProduct : Product {
6.     override fun use() {
7.         println("Using ConcreteProduct")
8.     }
9. }
11. abstract class Creator {
12.     abstract fun factoryMethod(): Product
13. }
15. class ConcreteCreator : Creator() {
16.     override fun factoryMethod(): Product {
17.         return ConcreteProduct()
18.     }
19. }

复制代码

1.3 抽象工厂模式 (Abstract Factory)

目标: 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
Java 实现:

1. interface AbstractFactory {
2.     ProductA createProductA();
3.     ProductB createProductB();
4. }
6. class ConcreteFactory1 implements AbstractFactory {
7.     @Override
8.     public ProductA createProductA() {
9.         return new ConcreteProductA1();
10.     }
12.     @Override
13.     public ProductB createProductB() {
14.         return new ConcreteProductB1();
15.     }
16. }
18. class ConcreteFactory2 implements AbstractFactory {
19.     @Override
20.     public ProductA createProductA() {
21.         return new ConcreteProductA2();
22.     }
24.     @Override
25.     public ProductB createProductB() {
26.         return new ConcreteProductB2();
27.     }
28. }

复制代码

Kotlin 实现:

1. interface AbstractFactory {
2.     fun createProductA(): ProductA
3.     fun createProductB(): ProductB
4. }
6. class ConcreteFactory1 : AbstractFactory {
7.     override fun createProductA(): ProductA {
8.         return ConcreteProductA1()
9.     }
11.     override fun createProductB(): ProductB {
12.         return ConcreteProductB1()
13.     }
14. }
16. class ConcreteFactory2 : AbstractFactory {
17.     override fun createProductA(): ProductA {
18.         return ConcreteProductA2()
19.     }
21.     override fun createProductB(): ProductB {
22.         return ConcreteProductB2()
23.     }
24. }

复制代码

1.4 建造者模式 (Builder)

目标: 将一个复杂对象的构建与其体现分离，使得同样的构建过程可以创建不同的体现。
Java 实现:

1. class Product {
2.     private String partA;
3.     private String partB;
5.     public void setPartA(String partA) {
6.         this.partA = partA;
7.     }
9.     public void setPartB(String partB) {
10.         this.partB = partB;
11.     }
13.     @Override
14.     public String toString() {
15.         return "Product{partA='" + partA + "', partB='" + partB + "'}";
16.     }
17. }
19. interface Builder {
20.     void buildPartA();
21.     void buildPartB();
22.     Product getResult();
23. }
25. class ConcreteBuilder implements Builder {
26.     private Product product = new Product();
28.     @Override
29.     public void buildPartA() {
30.         product.setPartA("PartA");
31.     }
33.     @Override
34.     public void buildPartB() {
35.         product.setPartB("PartB");
36.     }
38.     @Override
39.     public Product getResult() {
40.         return product;
41.     }
42. }
44. class Director {
45.     private Builder builder;
47.     public Director(Builder builder) {
48.         this.builder = builder;
49.     }
51.     public void construct() {
52.         builder.buildPartA();
53.         builder.buildPartB();
54.     }
55. }

复制代码

Kotlin 实现:

1. class Product {
2.     var partA: String = ""
3.     var partB: String = ""
5.     override fun toString(): String {
6.         return "Product(partA='$partA', partB='$partB')"
7.     }
8. }
10. interface Builder {
11.     fun buildPartA()
12.     fun buildPartB()
13.     fun getResult(): Product
14. }
16. class ConcreteBuilder : Builder {
17.     private val product = Product()
19.     override fun buildPartA() {
20.         product.partA = "PartA"
21.     }
23.     override fun buildPartB() {
24.         product.partB = "PartB"
25.     }
27.     override fun getResult(): Product {
28.         return product
29.     }
30. }
32. class Director(private val builder: Builder) {
33.     fun construct() {
34.         builder.buildPartA()
35.         builder.buildPartB()
36.     }
37. }

复制代码

1.5 原型模式 (Prototype)

目标: 通过复制现有对象来创建新对象，而不是通过新建类。
Java 实现:

1. interface Prototype {
2.     Prototype clone();
3. }
5. class ConcretePrototype implements Prototype {
6.     private String field;
8.     public ConcretePrototype(String field) {
9.         this.field = field;
10.     }
12.     @Override
13.     public Prototype clone() {
14.         return new ConcretePrototype(this.field);
15.     }
17.     @Override
18.     public String toString() {
19.         return "ConcretePrototype{field='" + field + "'}";
20.     }
21. }

复制代码

Kotlin 实现:

1. interface Prototype {
2.     fun clone(): Prototype
3. }
5. class ConcretePrototype(private val field: String) : Prototype {
6.     override fun clone(): Prototype {
7.         return ConcretePrototype(field)
8.     }
10.     override fun toString(): String {
11.         return "ConcretePrototype(field='$field')"
12.     }
13. }

复制代码

2. 结构型模式

2.1 适配器模式 (Adapter)

目标: 将一个类的接口转换成客户盼望的另一个接口。
Java 实现:

1. interface Target {
2.     void request();
3. }
5. class Adaptee {
6.     public void specificRequest() {
7.         System.out.println("Specific request");
8.     }
9. }
11. class Adapter implements Target {
12.     private Adaptee adaptee;
14.     public Adapter(Adaptee adaptee) {
15.         this.adaptee = adaptee;
16.     }
18.     @Override
19.     public void request() {
20.         adaptee.specificRequest();
21.     }
22. }

复制代码

Kotlin 实现:

1. interface Target {
2.     fun request()
3. }
5. class Adaptee {
6.     fun specificRequest() {
7.         println("Specific request")
8.     }
9. }
11. class Adapter(private val adaptee: Adaptee) : Target {
12.     override fun request() {
13.         adaptee.specificRequest()
14.     }
15. }

复制代码

2.2 桥接模式 (Bridge)

目标: 将抽象部分与实现部分分离，使它们可以独立厘革。
Java 实现:

1. interface Implementor {
2.     void operationImpl();
3. }
5. class ConcreteImplementorA implements Implementor {
6.     @Override
7.     public void operationImpl() {
8.         System.out.println("ConcreteImplementorA operation");
9.     }
10. }
12. class ConcreteImplementorB implements Implementor {
13.     @Override
14.     public void operationImpl() {
15.         System.out.println("ConcreteImplementorB operation");
16.     }
17. }
19. abstract class Abstraction {
20.     protected Implementor implementor;
22.     public Abstraction(Implementor implementor) {
23.         this.implementor = implementor;
24.     }
26.     public abstract void operation();
27. }
29. class RefinedAbstraction extends Abstraction {
30.     public RefinedAbstraction(Implementor implementor) {
31.         super(implementor);
32.     }
34.     @Override
35.     public void operation() {
36.         implementor.operationImpl();
37.     }
38. }

复制代码

Kotlin 实现:

1. interface Implementor {
2.     fun operationImpl()
3. }
5. class ConcreteImplementorA : Implementor {
6.     override fun operationImpl() {
7.         println("ConcreteImplementorA operation")
8.     }
9. }
11. class ConcreteImplementorB : Implementor {
12.     override fun operationImpl() {
13.         println("ConcreteImplementorB operation")
14.     }
15. }
17. abstract class Abstraction(protected val implementor: Implementor) {
18.     abstract fun operation()
19. }
21. class RefinedAbstraction(implementor: Implementor) : Abstraction(implementor) {
22.     override fun operation() {
23.         implementor.operationImpl()
24.     }
25. }

复制代码

2.3 组合模式 (Composite)

目标: 将对象组合成树形结构以体现“部分-整体”的层次结构。
Java 实现:

1. interface Component {
2.     void operation();
3. }
5. class Leaf implements Component {
6.     @Override
7.     public void operation() {
8.         System.out.println("Leaf operation");
9.     }
10. }
12. class Composite implements Component {
13.     private List<Component> children = new ArrayList<>();
15.     public void add(Component component) {
16.         children.add(component);
17.     }
19.     public void remove(Component component) {
20.         children.remove(component);
21.     }
23.     @Override
24.     public void operation() {
25.         for (Component component : children) {
26.             component.operation();
27.         }
28.     }
29. }

复制代码

Kotlin 实现:

1. interface Component {
2.     fun operation()
3. }
5. class Leaf : Component {
6.     override fun operation() {
7.         println("Leaf operation")
8.     }
9. }
11. class Composite : Component {
12.     private val children = mutableListOf<Component>()
14.     fun add(component: Component) {
15.         children.add(component)
16.     }
18.     fun remove(component: Component) {
19.         children.remove(component)
20.     }
22.     override fun operation() {
23.         for (component in children) {
24.             component.operation()
25.         }
26.     }
27. }

复制代码

2.4 装饰器模式 (Decorator)

目标: 动态地给对象添加一些额外的职责。
Java 实现:

1. interface Component {
2.     void operation();
3. }
5. class ConcreteComponent implements Component {
6.     @Override
7.     public void operation() {
8.         System.out.println("ConcreteComponent operation");
9.     }
10. }
12. abstract class Decorator implements Component {
13.     protected Component component;
15.     public Decorator(Component component) {
16.         this.component = component;
17.     }
19.     @Override
20.     public void operation() {
21.         component.operation();
22.     }
23. }
25. class ConcreteDecoratorA extends Decorator {
26.     public ConcreteDecoratorA(Component component) {
27.         super(component);
28.     }
30.     @Override
31.     public void operation() {
32.         super.operation();
33.         addedBehavior();
34.     }
36.     private void addedBehavior() {
37.         System.out.println("ConcreteDecoratorA added behavior");
38.     }
39. }
41. class ConcreteDecoratorB extends Decorator {
42.     public ConcreteDecoratorB(Component component) {
43.         super(component);
44.     }
46.     @Override
47.     public void operation() {
48.         super.operation();
49.         addedBehavior();
50.     }
52.     private void addedBehavior() {
53.         System.out.println("ConcreteDecoratorB added behavior");
54.     }
55. }

复制代码

Kotlin 实现:

1. interface Component {
2.     fun operation()
3. }
5. class ConcreteComponent : Component {
6.     override fun operation() {
7.         println("ConcreteComponent operation")
8.     }
9. }
11. abstract class Decorator(private val component: Component) : Component {
12.     override fun operation() {
13.         component.operation()
14.     }
15. }
17. class ConcreteDecoratorA(component: Component) : Decorator(component) {
18.     override fun operation() {
19.         super.operation()
20.         addedBehavior()
21.     }
23.     private fun addedBehavior() {
24.         println("ConcreteDecoratorA added behavior")
25.     }
26. }
28. class ConcreteDecoratorB(component: Component) : Decorator(component) {
29.     override fun operation() {
30.         super.operation()
31.         addedBehavior()
32.     }
34.     private fun addedBehavior() {
35.         println("ConcreteDecoratorB added behavior")
36.     }
37. }

复制代码

2.5 外观模式 (Facade)

目标: 为子系统中的一组接口提供一个同一的接口。
Java 实现:

1. class SubsystemA {
2.     public void operationA() {
3.         System.out.println("SubsystemA operation");
4.     }
5. }
7. class SubsystemB {
8.     public void operationB() {
9.         System.out.println("SubsystemB operation");
10.     }
11. }
13. class Facade {
14.     private SubsystemA subsystemA = new SubsystemA();
15.     private SubsystemB subsystemB = new SubsystemB();
17.     public void operation() {
18.         subsystemA.operationA();
19.         subsystemB.operationB();
20.     }
21. }

复制代码

Kotlin 实现:

1. class SubsystemA {
2.     fun operationA() {
3.         println("SubsystemA operation")
4.     }
5. }
7. class SubsystemB {
8.     fun operationB() {
9.         println("SubsystemB operation")
10.     }
11. }
13. class Facade {
14.     private val subsystemA = SubsystemA()
15.     private val subsystemB = SubsystemB()
17.     fun operation() {
18.         subsystemA.operationA()
19.         subsystemB.operationB()
20.     }
21. }

复制代码

2.6 享元模式 (Flyweight)

目标: 运用共享技能有效地支持大量细粒度的对象。
Java 实现:

1. class Flyweight {
2.     private String intrinsicState;
4.     public Flyweight(String intrinsicState) {
5.         this.intrinsicState = intrinsicState;
6.     }
8.     public void operation(String extrinsicState) {
9.         System.out.println("Intrinsic State = " + intrinsicState + ", Extrinsic State = " + extrinsicState);
10.     }
11. }
13. class FlyweightFactory {
14.     private Map<String, Flyweight> flyweights = new HashMap<>();
16.     public Flyweight getFlyweight(String key) {
17.         if (!flyweights.containsKey(key)) {
18.             flyweights.put(key, new Flyweight(key));
19.         }
20.         return flyweights.get(key);
21.     }
22. }

复制代码

Kotlin 实现:

1. class Flyweight(private val intrinsicState: String) {
2.     fun operation(extrinsicState: String) {
3.         println("Intrinsic State = $intrinsicState, Extrinsic State = $extrinsicState")
4.     }
5. }
7. class FlyweightFactory {
8.     private val flyweights = mutableMapOf<String, Flyweight>()
10.     fun getFlyweight(key: String): Flyweight {
11.         return flyweights.getOrPut(key) { Flyweight(key) }
12.     }
13. }

复制代码

2.7 署理模式 (Proxy)

目标: 为其他对象提供一个署理以控制对这个对象的访问。
Java 实现:

1. interface Subject {
2.     void request();
3. }
5. class RealSubject implements Subject {
6.     @Override
7.     public void request() {
8.         System.out.println("RealSubject request");
9.     }
10. }
12. class Proxy implements Subject {
13.     private RealSubject realSubject;
15.     @Override
16.     public void request() {
17.         if (realSubject == null) {
18.             realSubject = new RealSubject();
19.         }
20.         realSubject.request();
21.     }
22. }

复制代码

Kotlin 实现:

1. interface Subject {
2.     fun request()
3. }
5. class RealSubject : Subject {
6.     override fun request() {
7.         println("RealSubject request")
8.     }
9. }
11. class Proxy : Subject {
12.     private var realSubject: RealSubject? = null
14.     override fun request() {
15.         if (realSubject == null) {
16.             realSubject = RealSubject()
17.         }
18.         realSubject?.request()
19.     }
20. }

复制代码

3. 举动型模式

3.1 责任链模式 (Chain of Responsibility)

目标: 使多个对象都有时机处置处罚请求，从而避免请求的发送者与吸收者之间的耦合。
Java 实现:

1. abstract class Handler {
2.     protected Handler successor;
4.     public void setSuccessor(Handler successor) {
5.         this.successor = successor;
6.     }
8.     public abstract void handleRequest(String request);
9. }
11. class ConcreteHandlerA extends Handler {
12.     @Override
13.     public void handleRequest(String request) {
14.         if (request.equals("A")) {
15.             System.out.println("ConcreteHandlerA handles request");
16.         } else if (successor != null) {
17.             successor.handleRequest(request);
18.         }
19.     }
20. }
22. class ConcreteHandlerB extends Handler {
23.     @Override
24.     public void handleRequest(String request) {
25.         if (request.equals("B")) {
26.             System.out.println("ConcreteHandlerB handles request");
27.         } else if (successor != null) {
28.             successor.handleRequest(request);
29.         }
30.     }
31. }

复制代码

Kotlin 实现:

1. abstract class Handler {
2.     var successor: Handler? = null
4.     abstract fun handleRequest(request: String)
5. }
7. class ConcreteHandlerA : Handler() {
8.     override fun handleRequest(request: String) {
9.         if (request == "A") {
10.             println("ConcreteHandlerA handles request")
11.         } else {
12.             successor?.handleRequest(request)
13.         }
14.     }
15. }
17. class ConcreteHandlerB : Handler() {
18.     override fun handleRequest(request: String) {
19.         if (request == "B") {
20.             println("ConcreteHandlerB handles request")
21.         } else {
22.             successor?.handleRequest(request)
23.         }
24.     }
25. }

复制代码

3.2 下令模式 (Command)

目标: 将请求封装为对象，从而使你可以用不同的请求对客户进行参数化。
Java 实现:

1. interface Command {
2.     void execute();
3. }
5. class ConcreteCommand implements Command {
6.     private Receiver receiver;
8.     public ConcreteCommand(Receiver receiver) {
9.         this.receiver = receiver;
10.     }
12.     @Override
13.     public void execute() {
14.         receiver.action();
15.     }
16. }
18. class Receiver {
19.     public void action() {
20.         System.out.println("Receiver action");
21.     }
22. }
24. class Invoker {
25.     private Command command;
27.     public void setCommand(Command command) {
28.         this.command = command;
29.     }
31.     public void executeCommand() {
32.         command.execute();
33.     }
34. }

复制代码

Kotlin 实现:

1. interface Command {
2.     fun execute()
3. }
5. class ConcreteCommand(private val receiver: Receiver) : Command {
6.     override fun execute() {
7.         receiver.action()
8.     }
9. }
11. class Receiver {
12.     fun action() {
13.         println("Receiver action")
14.     }
15. }
17. class Invoker {
18.     private var command: Command? = null
20.     fun setCommand(command: Command) {
21.         this.command = command
22.     }
24.     fun executeCommand() {
25.         command?.execute()
26.     }
27. }

复制代码

3.3 解释器模式 (Interpreter)

目标: 给定一个语言，定义它的文法的一种体现，并定义一个解释器，这个解释器使用该体现来解释语言中的句子。
Java 实现:

1. class OrExpression implements Expression {
2.     private Expression expr1;
3.     private Expression expr2;
5.     public OrExpression(Expression expr1, Expression expr2) {
6.         this.expr1 = expr1;
7.         this.expr2 = expr2;
8.     }
10.     @Override
11.     public boolean interpret(String context) {
12.         return expr1.interpret(context) || expr2.interpret(context);
13.     }
14. }
16. class AndExpression implements Expression {
17.     private Expression expr1;
18.     private Expression expr2;
20.     public AndExpression(Expression expr1, Expression expr2) {
21.         this.expr1 = expr1;
22.         this.expr2 = expr2;
23.     }
25.     @Override
26.     public boolean interpret(String context) {
27.         return expr1.interpret(context) && expr2.interpret(context);
28.     }
29. }
31. // 使用示例
32. public class InterpreterPatternDemo {
33.     public static void main(String[] args) {
34.         Expression isMale = new TerminalExpression("John");
35.         Expression isMarriedWoman = new AndExpression(new TerminalExpression("Julie"), new TerminalExpression("Married"));
36.         Expression isSingleOrMale = new OrExpression(isMale, new TerminalExpression("Single"));
38.         System.out.println("John is male? " + isMale.interpret("John"));
39.         System.out.println("Julie is a married woman? " + isMarriedWoman.interpret("Married Julie"));
40.         System.out.println("Is John single or male? " + isSingleOrMale.interpret("Single John"));
41.     }
42. }

复制代码

Kotlin 实现:

1. interface Expression {
2.     fun interpret(context: String): Boolean
3. }
5. class TerminalExpression(private val data: String) : Expression {
6.     override fun interpret(context: String): Boolean {
7.         return context.contains(data)
8.     }
9. }
11. class OrExpression(private val expr1: Expression, private val expr2: Expression) : Expression {
12.     override fun interpret(context: String): Boolean {
13.         return expr1.interpret(context) || expr2.interpret(context)
14.     }
15. }
17. class AndExpression(private val expr1: Expression, private val expr2: Expression) : Expression {
18.     override fun interpret(context: String): Boolean {
19.         return expr1.interpret(context) && expr2.interpret(context)
20.     }
21. }
23. // 使用示例
24. fun main() {
25.     val isMale = TerminalExpression("John")
26.     val isMarriedWoman = AndExpression(TerminalExpression("Julie"), TerminalExpression("Married"))
27.     val isSingleOrMale = OrExpression(isMale, TerminalExpression("Single"))
29.     println("John is male? ${isMale.interpret("John")}")
30.     println("Julie is a married woman? ${isMarriedWoman.interpret("Married Julie")}")
31.     println("Is John single or male? ${isSingleOrMale.interpret("Single John")}")
32. }

复制代码

3.4 迭代器模式 (Iterator)

目标: 提供一种方法序次访问一个聚合对象中的各个元素，而又不暴露其内部体现。
Java 实现:

1. interface Iterator<T> {
2.     boolean hasNext();
3.     T next();
4. }
6. interface Container<T> {
7.     Iterator<T> getIterator();
8. }
10. class NameRepository implements Container<String> {
11.     private String[] names = {"John", "Julie", "Adam", "Eve"};
13.     @Override
14.     public Iterator<String> getIterator() {
15.         return new NameIterator();
16.     }
18.     private class NameIterator implements Iterator<String> {
19.         private int index;
21.         @Override
22.         public boolean hasNext() {
23.             return index < names.length;
24.         }
26.         @Override
27.         public String next() {
28.             if (hasNext()) {
29.                 return names[index++];
30.             }
31.             return null;
32.         }
33.     }
34. }
36. // 使用示例
37. public class IteratorPatternDemo {
38.     public static void main(String[] args) {
39.         NameRepository nameRepository = new NameRepository();
40.         Iterator<String> iterator = nameRepository.getIterator();
42.         while (iterator.hasNext()) {
43.             System.out.println("Name: " + iterator.next());
44.         }
45.     }
46. }

复制代码

Kotlin 实现:

1. interface Iterator<T> {
2.     fun hasNext(): Boolean
3.     fun next(): T
4. }
6. interface Container<T> {
7.     fun getIterator(): Iterator<T>
8. }
10. class NameRepository : Container<String> {
11.     private val names = arrayOf("John", "Julie", "Adam", "Eve")
13.     override fun getIterator(): Iterator<String> {
14.         return NameIterator()
15.     }
17.     private inner class NameIterator : Iterator<String> {
18.         private var index = 0
20.         override fun hasNext(): Boolean {
21.             return index < names.size
22.         }
24.         override fun next(): String {
25.             return if (hasNext()) {
26.                 names[index++]
27.             } else {
28.                 throw NoSuchElementException()
29.             }
30.         }
31.     }
32. }
34. // 使用示例
35. fun main() {
36.     val nameRepository = NameRepository()
37.     val iterator = nameRepository.getIterator()
39.     while (iterator.hasNext()) {
40.         println("Name: ${iterator.next()}")
41.     }
42. }

复制代码

3.5 中介者模式 (Mediator)

目标: 定义一个中介对象来封装一系列对象之间的交互，使它们不需要显式地相互引用。
Java 实现:

1. interface Mediator {
2.     void send(String message, Colleague colleague);
3. }
5. abstract class Colleague {
6.     protected Mediator mediator;
8.     public Colleague(Mediator mediator) {
9.         this.mediator = mediator;
10.     }
12.     public abstract void send(String message);
13.     public abstract void receive(String message);
14. }
16. class ConcreteColleagueA extends Colleague {
17.     public ConcreteColleagueA(Mediator mediator) {
18.         super(mediator);
19.     }
21.     @Override
22.     public void send(String message) {
23.         mediator.send(message, this);
24.     }
26.     @Override
27.     public void receive(String message) {
28.         System.out.println("ConcreteColleagueA received: " + message);
29.     }
30. }
32. class ConcreteColleagueB extends Colleague {
33.     public ConcreteColleagueB(Mediator mediator) {
34.         super(mediator);
35.     }
37.     @Override
38.     public void send(String message) {
39.         mediator.send(message, this);
40.     }
42.     @Override
43.     public void receive(String message) {
44.         System.out.println("ConcreteColleagueB received: " + message);
45.     }
46. }
48. class ConcreteMediator implements Mediator {
49.     private ConcreteColleagueA colleagueA;
50.     private ConcreteColleagueB colleagueB;
52.     public void setColleagueA(ConcreteColleagueA colleagueA) {
53.         this.colleagueA = colleagueA;
54.     }
56.     public void setColleagueB(ConcreteColleagueB colleagueB) {
57.         this.colleagueB = colleagueB;
58.     }
60.     @Override
61.     public void send(String message, Colleague colleague) {
62.         if (colleague == colleagueA) {
63.             colleagueB.receive(message);
64.         } else {
65.             colleagueA.receive(message);
66.         }
67.     }
68. }
70. // 使用示例
71. public class MediatorPatternDemo {
72.     public static void main(String[] args) {
73.         ConcreteMediator mediator = new ConcreteMediator();
74.         ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
75.         ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
77.         mediator.setColleagueA(colleagueA);
78.         mediator.setColleagueB(colleagueB);
80.         colleagueA.send("Hello from A");
81.         colleagueB.send("Hi from B");
82.     }
83. }

复制代码

Kotlin 实现:

1. interface Mediator {
2.     fun send(message: String, colleague: Colleague)
3. }
5. abstract class Colleague(protected val mediator: Mediator) {
6.     abstract fun send(message: String)
7.     abstract fun receive(message: String)
8. }
10. class ConcreteColleagueA(mediator: Mediator) : Colleague(mediator) {
11.     override fun send(message: String) {
12.         mediator.send(message, this)
13.     }
15.     override fun receive(message: String) {
16.         println("ConcreteColleagueA received: $message")
17.     }
18. }
20. class ConcreteColleagueB(mediator: Mediator) : Colleague(mediator) {
21.     override fun send(message: String) {
22.         mediator.send(message, this)
23.     }
25.     override fun receive(message: String) {
26.         println("ConcreteColleagueB received: $message")
27.     }
28. }
30. class ConcreteMediator : Mediator {
31.     private lateinit var colleagueA: ConcreteColleagueA
32.     private lateinit var colleagueB: ConcreteColleagueB
34.     fun setColleagueA(colleagueA: ConcreteColleagueA) {
35.         this.colleagueA = colleagueA
36.     }
38.     fun setColleagueB(colleagueB: ConcreteColleagueB) {
39.         this.colleagueB = colleagueB
40.     }
42.     override fun send(message: String, colleague: Colleague) {
43.         when (colleague) {
44.             colleagueA -> colleagueB.receive(message)
45.             else -> colleagueA.receive(message)
46.         }
47.     }
48. }
50. // 使用示例
51. fun main() {
52.     val mediator = ConcreteMediator()
53.     val colleagueA = ConcreteColleagueA(mediator)
54.     val colleagueB = ConcreteColleagueB(mediator)
56.     mediator.setColleagueA(colleagueA)
57.     mediator.setColleagueB(colleagueB)
59.     colleagueA.send("Hello from A")
60.     colleagueB.send("Hi from B")
61. }

复制代码

3.6 备忘录模式 (Memento)

目标: 在不粉碎封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
Java 实现:

1. class Memento {
2.     private String state;
4.     public Memento(String state) {
5.         this.state = state;
6.     }
8.     public String getState() {
9.         return state;
10.     }
11. }
13. class Originator {
14.     private String state;
16.     public void setState(String state) {
17.         this.state = state;
18.     }
20.     public String getState() {
21.         return state;
22.     }
24.     public Memento saveStateToMemento() {
25.         return new Memento(state);
26.     }
28.     public void getStateFromMemento(Memento memento) {
29.         state = memento.getState();
30.     }
31. }
33. class CareTaker {
34.     private List<Memento> mementoList = new ArrayList<>();
36.     public void add(Memento state) {
37.         mementoList.add(state);
38.     }
40.     public Memento get(int index) {
41.         return mementoList.get(index);
42.     }
43. }
45. // 使用示例
46. public class MementoPatternDemo {
47.     public static void main(String[] args) {
48.         Originator originator = new Originator();
49.         CareTaker careTaker = new CareTaker();
51.         originator.setState("State #1");
52.         careTaker.add(originator.saveStateToMemento());
54.         originator.setState("State #2");
55.         careTaker.add(originator.saveStateToMemento());
57.         originator.setState("State #3");
58.         careTaker.add(originator.saveStateToMemento());
60.         System.out.println("Current State: " + originator.getState());
61.         originator.getStateFromMemento(careTaker.get(0));
62.         System.out.println("First saved State: " + originator.getState());
63.         originator.getStateFromMemento(careTaker.get(1));
64.         System.out.println("Second saved State: " + originator.getState());
65.     }
66. }

复制代码

Kotlin 实现:

1. class Memento(val state: String)
3. class Originator {
4.     private var state: String = ""
6.     fun setState(state: String) {
7.         this.state = state
8.     }
10.     fun getState(): String {
11.         return state
12.     }
14.     fun saveStateToMemento(): Memento {
15.         return Memento(state)
16.     }
18.     fun getStateFromMemento(memento: Memento) {
19.         state = memento.state
20.     }
21. }
23. class CareTaker {
24.     private val mementoList = mutableListOf<Memento>()
26.     fun add(state: Memento) {
27.         mementoList.add(state)
28.     }
30.     fun get(index: Int): Memento {
31.         return mementoList[index]
32.     }
33. }
35. // 使用示例
36. fun main() {
37.     val originator = Originator()
38.     val careTaker = CareTaker()
40.     originator.setState("State #1")
41.     careTaker.add(originator.saveStateToMemento())
43.     originator.setState("State #2")
44.     careTaker.add(originator.saveStateToMemento())
46.     originator.setState("State #3")
47.     careTaker.add(originator.saveStateToMemento())
49.     println("Current State: ${originator.getState()}")
50.     originator.getStateFromMemento(careTaker.get(0))
51.     println("First saved State: ${originator.getState()}")
52.     originator.getStateFromMemento(careTaker.get(1))
53.     println("Second saved State: ${originator.getState()}")
54. }

复制代码

3.7 观察者模式 (Observer)

目标: 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，全部依赖于它的对象都得到通知并被自动更新。
Java 实现:

1. interface Observer {
2.     void update(String message);
3. }
5. class ConcreteObserver implements Observer {
6.     private String name;
8.     public ConcreteObserver(String name) {
9.         this.name = name;
10.     }
12.     @Override
13.     public void update(String message) {
14.         System.out.println(name + " received message: " + message);
15.     }
16. }
18. class Subject {
19.     private List<Observer> observers = new ArrayList<>();
20.     private String state;
22.     public void setState(String state) {
23.         this.state = state;
24.         notifyAllObservers();
25.     }
27.     public void attach(Observer observer) {
28.         observers.add(observer);
29.     }
31.     public void notifyAllObservers() {
32.         for (Observer observer : observers) {
33.             observer.update(state);
34.         }
35.     }
36. }
38. // 使用示例
39. public class ObserverPatternDemo {
40.     public static void main(String[] args) {
41.         Subject subject = new Subject();
43.         Observer observer1 = new ConcreteObserver("Observer 1");
44.         Observer observer2 = new ConcreteObserver("Observer 2");
46.         subject.attach(observer1);
47.         subject.attach(observer2);
49.         subject.setState("State #1");
50.         subject.setState("State #2");
51.     }
52. }

复制代码

Kotlin 实现:

1. interface Observer {
2.     fun update(message: String)
3. }
5. class ConcreteObserver(private val name: String) : Observer {
6.     override fun update(message: String) {
7.         println("$name received message: $message")
8.     }
9. }
11. class Subject {
12.     private val observers = mutableListOf<Observer>()
13.     private var state: String = ""
15.     fun setState(state: String) {
16.         this.state = state
17.         notifyAllObservers()
18.     }
20.     fun attach(observer: Observer) {
21.         observers.add(observer)
22.     }
24.     private fun notifyAllObservers() {
25.         for (observer in observers) {
26.             observer.update(state)
27.         }
28.     }
29. }
31. // 使用示例
32. fun main() {
33.     val subject = Subject()
35.     val observer1 = ConcreteObserver("Observer 1")
36.     val observer2 = ConcreteObserver("Observer 2")
38.     subject.attach(observer1)
39.     subject.attach(observer2)
41.     subject.setState("State #1")
42.     subject.setState("State #2")
43. }

复制代码

3.8 状态模式 (State)

目标: 允许一个对象在其内部状态改变时改变它的举动。
Java 实现:

1. interface State {
2.     void handle(Context context);
3. }
5. class ConcreteStateA implements State {
6.     @Override
7.     public void handle(Context context) {
8.         System.out.println("Handling in State A");
9.         context.setState(new ConcreteStateB());
10.     }
11. }
13. class ConcreteStateB implements State {
14.     @Override
15.     public void handle(Context context) {
16.         System.out.println("Handling in State B");
17.         context.setState(new ConcreteStateA());
18.     }
19. }
21. class Context {
22.     private State state;
24.     public Context(State state) {
25.         this.state = state;
26.     }
28.     public void setState(State state) {
29.         this.state = state;
30.     }
32.     public void request() {
33.         state.handle(this);
34.     }
35. }
37. // 使用示例
38. public class StatePatternDemo {
39.     public static void main(String[] args) {
40.         Context context = new Context(new ConcreteStateA());
42.         context.request();
43.         context.request();
44.         context.request();
45.     }
46. }

复制代码

Kotlin 实现:

1. interface State {
2.     fun handle(context: Context)
3. }
5. class ConcreteStateA : State {
6.     override fun handle(context: Context) {
7.         println("Handling in State A")
8.         context.setState(ConcreteStateB())
9.     }
10. }
12. class ConcreteStateB : State {
13.     override fun handle(context: Context) {
14.         println("Handling in State B")
15.         context.setState(ConcreteStateA())
16.     }
17. }
19. class Context(private var state: State) {
20.     fun setState(state: State) {
21.         this.state = state
22.     }
24.     fun request() {
25.         state.handle(this)
26.     }
27. }
29. // 使用示例
30. fun main() {
31.     val context = Context(ConcreteStateA())
33.     context.request()
34.     context.request()
35.     context.request()
36. }

复制代码

3.9 计谋模式 (Strategy)

目标: 定义一系列算法，将它们封装起来，并且使它们可以相互更换。
Java 实现:

1. interface Strategy {
2.     int doOperation(int num1, int num2);
3. }
5. class OperationAdd implements Strategy {
6.     @Override
7.     public int doOperation(int num1, int num2) {
8.         return num1 + num2;
9.     }
10. }
12. class OperationSubtract implements Strategy {
13.     @Override
14.     public int doOperation(int num1, int num2) {
15.         return num1 - num2;
16.     }
17. }
19. class OperationMultiply implements Strategy {
20.     @Override
21.     public int doOperation(int num1, int num2) {
22.         return num1 * num2;
23.     }
24. }
26. class Context {
27.     private Strategy strategy;
29.     public Context(Strategy strategy) {
30.         this.strategy = strategy;
31.     }
33.     public int executeStrategy(int num1, int num2) {
34.         return strategy.doOperation(num1, num2);
35.     }
36. }
38. // 使用示例
39. public class StrategyPatternDemo {
40.     public static void main(String[] args) {
41.         Context context = new Context(new OperationAdd());
42.         System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
44.         context = new Context(new OperationSubtract());
45.         System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
47.         context = new Context(new OperationMultiply());
48.         System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
49.     }
50. }

复制代码

Kotlin 实现:

1. interface Strategy {
2.     fun doOperation(num1: Int, num2: Int): Int
3. }
5. class OperationAdd : Strategy {
6.     override fun doOperation(num1: Int, num2: Int): Int {
7.         return num1 + num2
8.     }
9. }
11. class OperationSubtract : Strategy {
12.     override fun doOperation(num1: Int, num2: Int): Int {
13.         return num1 - num2
14.     }
15. }
16. class OperationMultiply : Strategy {
17.     override fun doOperation(num1: Int, num2: Int): Int {
18.         return num1 * num2
19.     }
20. }
22. class Context(private var strategy: Strategy) {
23.     fun executeStrategy(num1: Int, num2: Int): Int {
24.         return strategy.doOperation(num1, num2)
25.     }
26. }
28. // 使用示例
29. fun main() {
30.     var context = Context(OperationAdd())
31.     println("10 + 5 = ${context.executeStrategy(10, 5)}")
33.     context = Context(OperationSubtract())
34.     println("10 - 5 = ${context.executeStrategy(10, 5)}")
36.     context = Context(OperationMultiply())
37.     println("10 * 5 = ${context.executeStrategy(10, 5)}")
38. }

复制代码

3.10 模板方法模式 (Template Method)

目标: 定义一个操作中的算法骨架，而将一些步骤延迟到子类中。
Java 实现:

1. abstract class Game {
2.     abstract void initialize();
3.     abstract void startPlay();
4.     abstract void endPlay();
6.     // 模板方法
7.     public final void play() {
8.         initialize();
9.         startPlay();
10.         endPlay();
11.     }
12. }
14. class Cricket extends Game {
15.     @Override
16.     void initialize() {
17.         System.out.println("Cricket Game Initialized!");
18.     }
20.     @Override
21.     void startPlay() {
22.         System.out.println("Cricket Game Started!");
23.     }
25.     @Override
26.     void endPlay() {
27.         System.out.println("Cricket Game Finished!");
28.     }
29. }
31. class Football extends Game {
32.     @Override
33.     void initialize() {
34.         System.out.println("Football Game Initialized!");
35.     }
37.     @Override
38.     void startPlay() {
39.         System.out.println("Football Game Started!");
40.     }
42.     @Override
43.     void endPlay() {
44.         System.out.println("Football Game Finished!");
45.     }
46. }
48. // 使用示例
49. public class TemplateMethodPatternDemo {
50.     public static void main(String[] args) {
51.         Game game = new Cricket();
52.         game.play();
54.         game = new Football();
55.         game.play();
56.     }
57. }

复制代码

Kotlin 实现:

1. abstract class Game {
2.     abstract fun initialize()
3.     abstract fun startPlay()
4.     abstract fun endPlay()
6.     // 模板方法
7.     fun play() {
8.         initialize()
9.         startPlay()
10.         endPlay()
11.     }
12. }
14. class Cricket : Game() {
15.     override fun initialize() {
16.         println("Cricket Game Initialized!")
17.     }
19.     override fun startPlay() {
20.         println("Cricket Game Started!")
21.     }
23.     override fun endPlay() {
24.         println("Cricket Game Finished!")
25.     }
26. }
28. class Football : Game() {
29.     override fun initialize() {
30.         println("Football Game Initialized!")
31.     }
33.     override fun startPlay() {
34.         println("Football Game Started!")
35.     }
37.     override fun endPlay() {
38.         println("Football Game Finished!")
39.     }
40. }
42. // 使用示例
43. fun main() {
44.     var game: Game = Cricket()
45.     game.play()
47.     game = Football()
48.     game.play()
49. }

复制代码

3.11 访问者模式 (Visitor)

目标: 体现一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
Java 实现:

1. interface ComputerPartVisitor {
2.     void visit(Computer computer);
3.     void visit(Mouse mouse);
4.     void visit(Keyboard keyboard);
5.     void visit(Monitor monitor);
6. }
8. interface ComputerPart {
9.     void accept(ComputerPartVisitor computerPartVisitor);
10. }
12. class Keyboard implements ComputerPart {
13.     @Override
14.     public void accept(ComputerPartVisitor computerPartVisitor) {
15.         computerPartVisitor.visit(this);
16.     }
17. }
19. class Monitor implements ComputerPart {
20.     @Override
21.     public void accept(ComputerPartVisitor computerPartVisitor) {
22.         computerPartVisitor.visit(this);
23.     }
24. }
26. class Mouse implements ComputerPart {
27.     @Override
28.     public void accept(ComputerPartVisitor computerPartVisitor) {
29.         computerPartVisitor.visit(this);
30.     }
31. }
33. class Computer implements ComputerPart {
34.     ComputerPart[] parts;
36.     public Computer() {
37.         parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};
38.     }
40.     @Override
41.     public void accept(ComputerPartVisitor computerPartVisitor) {
42.         for (ComputerPart part : parts) {
43.             part.accept(computerPartVisitor);
44.         }
45.         computerPartVisitor.visit(this);
46.     }
47. }
49. class ComputerPartDisplayVisitor implements ComputerPartVisitor {
50.     @Override
51.     public void visit(Computer computer) {
52.         System.out.println("Displaying Computer.");
53.     }
55.     @Override
56.     public void visit(Mouse mouse) {
57.         System.out.println("Displaying Mouse.");
58.     }
60.     @Override
61.     public void visit(Keyboard keyboard) {
62.         System.out.println("Displaying Keyboard.");
63.     }
65.     @Override
66.     public void visit(Monitor monitor) {
67.         System.out.println("Displaying Monitor.");
68.     }
69. }
71. // 使用示例
72. public class VisitorPatternDemo {
73.     public static void main(String[] args) {
74.         ComputerPart computer = new Computer();
75.         computer.accept(new ComputerPartDisplayVisitor());
76.     }
77. }

复制代码

Kotlin 实现:

1. interface ComputerPartVisitor {
2.     fun visit(computer: Computer)
3.     fun visit(mouse: Mouse)
4.     fun visit(keyboard: Keyboard)
5.     fun visit(monitor: Monitor)
6. }
8. interface ComputerPart {
9.     fun accept(computerPartVisitor: ComputerPartVisitor)
10. }
12. class Keyboard : ComputerPart {
13.     override fun accept(computerPartVisitor: ComputerPartVisitor) {
14.         computerPartVisitor.visit(this)
15.     }
16. }
18. class Monitor : ComputerPart {
19.     override fun accept(computerPartVisitor: ComputerPartVisitor) {
20.         computerPartVisitor.visit(this)
21.     }
22. }
24. class Mouse : ComputerPart {
25.     override fun accept(computerPartVisitor: ComputerPartVisitor) {
26.         computerPartVisitor.visit(this)
27.     }
28. }
30. class Computer : ComputerPart {
31.     private val parts = arrayOf(Mouse(), Keyboard(), Monitor())
33.     override fun accept(computerPartVisitor: ComputerPartVisitor) {
34.         for (part in parts) {
35.             part.accept(computerPartVisitor)
36.         }
37.         computerPartVisitor.visit(this)
38.     }
39. }
41. class ComputerPartDisplayVisitor : ComputerPartVisitor {
42.     override fun visit(computer: Computer) {
43.         println("Displaying Computer.")
44.     }
46.     override fun visit(mouse: Mouse) {
47.         println("Displaying Mouse.")
48.     }
50.     override fun visit(keyboard: Keyboard) {
51.         println("Displaying Keyboard.")
52.     }
54.     override fun visit(monitor: Monitor) {
55.         println("Displaying Monitor.")
56.     }
57. }
59. // 使用示例
60. fun main() {
61.     val computer = Computer()
62.     computer.accept(ComputerPartDisplayVisitor())
63. }

复制代码

---

以上是 23 种设计模式的详细实现，涵盖了创建型、结构型和举动型模式。每种模式都提供了 Java 和 Kotlin 的实现示例，并附有简朴的使用示例。盼望这些内容能帮助你更好地理解设计模式，并在实际开发中机动运用！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。