java的 23个设计模式
文兴一言
Java中的23个设计模式是软件开发中常见的问题解决方案，它们提供了一种可重用的设计思路和模板。这些设计模式可以分为创建型模式、结构型模式和行为型模式三大类。以下是对这23个设计模式的详细介绍：
一、创建型模式（Creational Patterns）
创建型模式主要关注对象的创建过程，以及如何隐藏对象的创建细节。
- 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。该模式通常用于资源管理，如数据库连接、缓存等。
- 工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但由子类决定实例化哪一个类。该模式使得类的实例化延迟到其子类。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
- 建造者模式（Builder Pattern）：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
- 原型模式（Prototype Pattern）：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。该模式允许通过复制一个已经存在的对象来创建一个新的对象，而不是重新创建。
二、结构型模式（Structural Patterns）
结构型模式主要关注对象之间的组合方式，以达到构建更大结构的目标。
- 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端所期望的另一种接口，从而使原本由于接口不兼容而不能一起工作的类能够一起工作。
- 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。
- 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更为灵活。
- 桥接模式（Bridge Pattern）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
- 外观模式（Facade Pattern）：为子系统中的一组接口提供一个一致的接口，从而使得子系统更加容易使用。
- 享元模式（Flyweight Pattern）：运用共享技术有效地支持大量细粒度对象的复用。
- 组合模式（Composite Pattern）：将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端对单个对象和组合对象的使用具有一致性。
三、行为型模式（Behavioral Patterns）
行为型模式主要关注对象之间的通信方式，以及如何合作共同完成任务。
- 策略模式（Strategy Pattern）：定义了一系列算法，并将每一个算法封装起来，使得它们可以互相替换。该模式使得算法可以独立于使用它的客户端而变化。
- 模板方法模式（Template Method Pattern）：定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。这使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。
- 观察者模式（Observer Pattern）：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新。
- 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中各个元素，而不需要暴露该对象的内部表示。
- 责任链模式（Chain of Responsibility Pattern）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
- 命令模式（Command Pattern）：将一个请求封装为一个对象，从而使你可以用不同的请求对客户端进行参数化、对请求排队或记录请求日志，以及支持可撤销的操作。
- 中介者模式（Mediator Pattern）：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
- 备忘录模式（Memento Pattern）：在不破坏封装性的前提下，捕获并外部化一个对象的内部状态，以便以后可以将该对象恢复到先前的状态。
- 状态模式（State Pattern）：允许对象在内部状态改变时改变它的行为，对象看起来似乎修改了它的类。
- 访问者模式（Visitor Pattern）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不修改各元素的类的前提下定义作用于这些元素的新操作。
- 解释器模式（Interpreter Pattern）：给定一个语言，定义它的文法表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
这些设计模式为开发者提供了一种可重用的设计思路和模板，有助于提高代码的可维护性、可扩展性和重用性。在实际应用中，开发者可以根据具体的问题和情境来选择合适的设计模式。
通义灵码
Java中的23个经典设计模式通常被称为Gang of Four (GoF) 设计模式，它们是由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides这四位作者在1994年合著的《设计模式：可复用面向对象软件的基础》一书中提出的。这些模式分为三大类：创建型模式、结构型模式和行为型模式。下面是每种模式的简要介绍和示例代码。
创建型模式
创建型模式关注对象的创建过程，使得系统独立于如何创建、组合和表示这些对象。
-
单例模式 (Singleton Pattern)
- 用途：确保一个类只有一个实例，并提供一个全局访问点。
- 示例代码：
java
public class Singleton { private static Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }
-
工厂方法模式 (Factory Method Pattern)
- 用途：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
- 示例代码：
java
interface Product { void use(); } class ConcreteProductA implements Product { @Override public void use() { System.out.println("Using ConcreteProductA"); } } class ConcreteProductB implements Product { @Override public void use() { System.out.println("Using ConcreteProductB"); } } interface Creator { Product createProduct(); } class ConcreteCreatorA implements Creator { @Override public Product createProduct() { return new ConcreteProductA(); } } class ConcreteCreatorB implements Creator { @Override public Product createProduct() { return new ConcreteProductB(); } }
-
抽象工厂模式 (Abstract Factory Pattern)
- 用途：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
- 示例代码：
java
interface GUIFactory { Button createButton(); Checkbox createCheckbox(); } class WinFactory implements GUIFactory { @Override public Button createButton() { return new WinButton(); } @Override public Checkbox createCheckbox() { return new WinCheckbox(); } } class MacFactory implements GUIFactory { @Override public Button createButton() { return new MacButton(); } @Override public Checkbox createCheckbox() { return new MacCheckbox(); } } interface Button { void paint(); } class WinButton implements Button { @Override public void paint() { System.out.println("Win Button"); } } class MacButton implements Button { @Override public void paint() { System.out.println("Mac Button"); } } interface Checkbox { void paint(); } class WinCheckbox implements Checkbox { @Override public void paint() { System.out.println("Win Checkbox"); } } class MacCheckbox implements Checkbox { @Override public void paint() { System.out.println("Mac Checkbox"); } }
-
建造者模式 (Builder Pattern)
- 用途：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
- 示例代码：
java
class Product { private String partA; private String partB; public void setPartA(String partA) { this.partA = partA; } public void setPartB(String partB) { this.partB = partB; } @Override public String toString() { return "Product{" + "partA='" + partA + '\'' + ", partB='" + partB + '\'' + '}'; } } interface Builder { void buildPartA(); void buildPartB(); Product getResult(); } class ConcreteBuilder implements Builder { private Product product = new Product(); @Override public void buildPartA() { product.setPartA("Part A"); } @Override public void buildPartB() { product.setPartB("Part B"); } @Override public Product getResult() { return product; } } class Director { private Builder builder; public void setBuilder(Builder builder) { this.builder = builder; } public Product construct() { builder.buildPartA(); builder.buildPartB(); return builder.getResult(); } }
-
原型模式 (Prototype Pattern)
- 用途：通过复制已有对象来创建新对象，而不是每次都重新创建。
- 示例代码：
java
interface Prototype { Prototype clone(); } class ConcretePrototype implements Prototype { private String field; public ConcretePrototype(String field) { this.field = field; } @Override public Prototype clone() { return new ConcretePrototype(field); } @Override public String toString() { return "ConcretePrototype{" + "field='" + field + '\'' + '}'; } }
结构型模式
结构型模式关注类和对象的组合，以形成更大的结构。
-
适配器模式 (Adapter Pattern)
- 用途：将一个类的接口转换成客户端所期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以协同工作。
- 示例代码：
java
interface Target { void request(); } class Adaptee { public void specificRequest() { System.out.println("Specific request"); } } class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } @Override public void request() { adaptee.specificRequest(); } }
-
桥接模式 (Bridge Pattern)
- 用途：将抽象部分与它的实现部分分离，使它们可以独立变化。
- 示例代码：
java
interface Implementor { void operationImpl(); } class ConcreteImplementorA implements Implementor { @Override public void operationImpl() { System.out.println("Operation implemented by ConcreteImplementorA"); } } class ConcreteImplementorB implements Implementor { @Override public void operationImpl() { System.out.println("Operation implemented by ConcreteImplementorB"); } } abstract class Abstraction { protected Implementor implementor; public void setImplementor(Implementor implementor) { this.implementor = implementor; } public abstract void operation(); } class RefinedAbstraction extends Abstraction { @Override public void operation() { implementor.operationImpl(); } }
-
组合模式 (Composite Pattern)
- 用途：将对象组合成树形结构以表示“部分-整体”的层次结构，使得客户端可以统一地处理单个对象和组合对象。
- 示例代码：
java
interface Component { void operation(); } class Leaf implements Component { @Override public void operation() { System.out.println("Leaf operation"); } } class Composite implements Component { private List<Component> children = new ArrayList<>(); public void add(Component component) { children.add(component); } public void remove(Component component) { children.remove(component); } @Override public void operation() { for (Component child : children) { child.operation(); } } }
-
装饰器模式 (Decorator Pattern)
- 用途：动态地给一个对象添加一些额外的职责，而不影响其他对象。
- 示例代码：
java
interface Component { void operation(); } class ConcreteComponent implements Component { @Override public void operation() { System.out.println("ConcreteComponent operation"); } } abstract class Decorator implements Component { protected Component component; public Decorator(Component component) { this.component = component; } @Override public void operation() { component.operation(); } } class ConcreteDecoratorA extends Decorator { public ConcreteDecoratorA(Component component) { super(component); } @Override public void operation() { super.operation(); addedBehavior(); } private void addedBehavior() { System.out.println("Added behavior in ConcreteDecoratorA"); } }
-
外观模式 (Facade Pattern)
- 用途：为子系统中的一组接口提供一个统一的高层接口，使得子系统更容易使用。
- 示例代码：
java
class SubsystemA { public void operationA() { System.out.println("SubsystemA operation"); } } class SubsystemB { public void operationB() { System.out.println("SubsystemB operation"); } } class Facade { private SubsystemA subsystemA; private SubsystemB subsystemB; public Facade() { subsystemA = new SubsystemA(); subsystemB = new SubsystemB(); } public void operation() { subsystemA.operationA(); subsystemB.operationB(); } }
-
享元模式 (Flyweight Pattern)
- 用途：运用共享技术有效地支持大量细粒度对象的复用。
- 示例代码：
java
interface Flyweight { void operation(int extrinsicState); } class ConcreteFlyweight implements Flyweight { private String intrinsicState; public ConcreteFlyweight(String intrinsicState) { this.intrinsicState = intrinsicState; } @Override public void operation(int extrinsicState) { System.out.println("Intrinsic State: " + intrinsicState); System.out.println("Extrinsic State: " + extrinsicState); } } class FlyweightFactory { private Map<String, Flyweight> flyweights = new HashMap<>(); public Flyweight getFlyweight(String key) { Flyweight flyweight = flyweights.get(key); if (flyweight == null) { flyweight = new ConcreteFlyweight(key); flyweights.put(key, flyweight); } return flyweight; } }
-
代理模式 (Proxy Pattern)
- 用途：为其他对象提供一种代理以控制对这个对象的访问。
- 示例代码：
java
interface Subject { void request(); } class RealSubject implements Subject { @Override public void request() { System.out.println("RealSubject request"); } } class Proxy implements Subject { private RealSubject realSubject; @Override public void request() { if (realSubject == null) { realSubject = new RealSubject(); } realSubject.request(); } }
行为型模式
行为型模式关注对象之间的交互，特别是对象之间如何分配职责。
-
责任链模式 (Chain of Responsibility Pattern)
- 用途：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。
- 示例代码：
java
abstract class Handler { protected Handler successor; public void setSuccessor(Handler successor) { this.successor = successor; } public abstract void handleRequest(int request); } class ConcreteHandlerA extends Handler { @Override public void handleRequest(int request) { if (request >= 0 && request < 10) { System.out.println("Handled by ConcreteHandlerA"); } else if (successor != null) { successor.handleRequest(request); } } } class ConcreteHandlerB extends Handler { @Override public void handleRequest(int request) { if (request >= 10 && request < 20) { System.out.println("Handled by ConcreteHandlerB"); } else if (successor != null) { successor.handleRequest(request); } } }
-
命令模式 (Command Pattern)
- 用途：将请求封装成对象，从而使你可以用不同的请求、队列或者日志来参数化其他对象；命令模式也支持可撤销的操作。
- 示例代码：
java
interface Command { void execute(); } class Receiver { public void action() { System.out.println("Action performed"); } } class ConcreteCommand implements Command { private Receiver receiver; public ConcreteCommand(Receiver receiver) { this.receiver = receiver; } @Override public void execute() { receiver.action(); } } class Invoker { private Command command; public void setCommand(Command command) { this.command = command; } public void executeCommand() { command.execute(); } }
-
解释器模式 (Interpreter Pattern)
- 用途：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
- 示例代码：
java
interface Expression { int interpret(Context context); } class NumberExpression implements Expression { private int number; public NumberExpression(int number) { this.number = number; } @Override public int interpret(Context context) { return number; } } class PlusExpression implements Expression { private Expression leftExpression; private Expression rightExpression; public PlusExpression(Expression leftExpression, Expression rightExpression) { this.leftExpression = leftExpression; this.rightExpression = rightExpression; } @Override public int interpret(Context context) { return leftExpression.interpret(context) + rightExpression.interpret(context); } } class Context { // 可以存储上下文信息 }
-
迭代器模式 (Iterator Pattern)
- 用途：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。
- 示例代码：
java
interface Iterator { boolean hasNext(); Object next(); } interface Aggregate { Iterator createIterator(); } class ConcreteAggregate implements Aggregate { private List<Object> items = new ArrayList<>(); public void addItem(Object item) { items.add(item); } @Override public Iterator createIterator() { return new ConcreteIterator(this); } public int size() { return items.size(); } public Object getItem(int index) { return items.get(index); } } class ConcreteIterator implements Iterator { private ConcreteAggregate aggregate; private int current = 0; public ConcreteIterator(ConcreteAggregate aggregate) { this.aggregate = aggregate; } @Override public boolean hasNext() { return current < aggregate.size(); } @Override public Object next() { if (this.hasNext()) { return aggregate.getItem(current++); } return null; } }
-
中介者模式 (Mediator Pattern)
- 用途：定义一个中介对象来封装一系列对象之间的交互，从而使对象之间松耦合。
- 示例代码：
java
interface Mediator { void send(String message, Colleague colleague); } class ConcreteMediator implements Mediator { private Colleague colleagueA; private Colleague colleagueB; public void setColleagueA(Colleague colleagueA) { this.colleagueA = colleagueA; } public void setColleagueB(Colleague colleagueB) { this.colleagueB = colleagueB; } @Override public void send(String message, Colleague colleague) { if (colleague == colleagueA) { colleagueB.notify(message); } else { colleagueA.notify(message); } } } abstract class Colleague { protected Mediator mediator; public Colleague(Mediator mediator) { this.mediator = mediator; } public abstract void send(String message); public abstract void notify(String message); } class ConcreteColleagueA extends Colleague { public ConcreteColleagueA(Mediator mediator) { super(mediator); } @Override public void send(String message) { mediator.send(message, this); } @Override public void notify(String message) { System.out.println("ColleagueA received: " + message); } } class ConcreteColleagueB extends Colleague { public ConcreteColleagueB(Mediator mediator) { super(mediator); } @Override public void send(String message) { mediator.send(message, this); } @Override public void notify(String message) { System.out.println("ColleagueB received: " + message); } }
备忘录模式 (Memento Pattern)
- 用途：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后将对象恢复到原先保存的状态。
- 示例代码：
java
class Originator { private String state; public void setState(String state) { this.state = state; } public String getState() { return state; } public Memento saveStateToMemento() { return new Memento(state); } public void getStateFromMemento(Memento memento) { state = memento.getState(); } } class Memento { private String state; public Memento(String state) { this.state = state; } public String getState() { return state; } } class Caretaker { private List<Memento> mementoList = new ArrayList<>(); public void add(Memento state) {
观察者模式 (Observer Pattern)
- 用途：定义对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
- 示例代码：
java
interface Observer { void update(String message); } interface Subject { void registerObserver(Observer observer); void removeObserver(Observer observer); void notifyObservers(String message); } class ConcreteSubject implements Subject { private List<Observer> observers = new ArrayList<>(); @Override public void registerObserver(Observer observer) { observers.add(observer); } @Override public void removeObserver(Observer observer) { observers.remove(observer); } @Override public void notifyObservers(String message) { for (Observer observer : observers) { observer.update(message); } } } class ConcreteObserver implements Observer { private String name; public ConcreteObserver(String name) { this.name = name; } @Override public void update(String message) { System.out.println(name + " received: " + message); } }
状态模式 (State Pattern)
- 用途：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。
- 示例代码：
java
interface State { void handle(Context context); } class ConcreteStateA implements State { @Override public void handle(Context context) { System.out.println("Handling with ConcreteStateA"); context.setState(new ConcreteStateB()); } } class ConcreteStateB implements State { @Override public void handle(Context context) { System.out.println("Handling with ConcreteStateB"); context.setState(new ConcreteStateA()); } } class Context { private State state; public Context(State state) { this.state = state; } public void setState(State state) { this.state = state; } public void request() { state.handle(this); } }
策略模式 (Strategy Pattern)
- 用途：定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。
- 示例代码：
java
interface Strategy { void execute(); } class ConcreteStrategyA implements Strategy { @Override public void execute() { System.out.println("Executing strategy A"); } } class ConcreteStrategyB implements Strategy { @Override public void execute() { System.out.println("Executing strategy B"); } } class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public void setStrategy(Strategy strategy) { this.strategy = strategy; } public void executeStrategy() { strategy.execute(); } }
模板方法模式 (Template Method Pattern)
- 用途：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
- 示例代码：
java
abstract class AbstractClass { public final void templateMethod() { step1(); step2(); hook(); } protected abstract void step1(); protected abstract void step2(); protected void hook() { // 默认实现为空，子类可以选择实现 } } class ConcreteClassA extends AbstractClass { @Override protected void step1() { System.out.println("Step 1 in ConcreteClassA"); } @Override protected void step2() { System.out.println("Step 2 in ConcreteClassA"); } @Override protected void hook() { System.out.println("Hook in ConcreteClassA"); } } class ConcreteClassB extends AbstractClass { @Override protected void step1() { System.out.println("Step 1 in ConcreteClassB"); } @Override protected void step2() { System.out.println("Step 2 in ConcreteClassB"); } }
访问者模式 (Visitor Pattern)
- 用途：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
- 示例代码：
java
interface Element { void accept(Visitor visitor); } class ConcreteElementA implements Element { @Override public void accept(Visitor visitor) { visitor.visit(this); } public void operationA() { System.out.println("Operation A in ConcreteElementA"); } } class ConcreteElementB implements Element { @Override public void accept(Visitor visitor) { visitor.visit(this); } public void operationB() { System.out.println("Operation B in ConcreteElementB"); } } interface Visitor { void visit(ConcreteElementA elementA); void visit(ConcreteElementB elementB); } class ConcreteVisitor1 implements Visitor { @Override public void visit(ConcreteElementA elementA) { elementA.operationA(); System.out.println("Visited ConcreteElementA with ConcreteVisitor1"); } @Override public void visit(ConcreteElementB elementB) { elementB.operationB(); System.out.println("Visited ConcreteElementB with ConcreteVisitor1"); } } class ConcreteVisitor2 implements Visitor { @Override public void visit(ConcreteElementA elementA) { elementA.operationA(); System.out.println("Visited ConcreteElementA with ConcreteVisitor2"); } @Override public void visit(ConcreteElementB elementB) { elementB.operationB(); System.out.println("Visited ConcreteElementB with ConcreteVisitor2"); } }
以上就是Java中的23个经典设计模式及其简要介绍和示例代码。每个模式都有其特定的应用场景和优点，合理使用这些设计模式可以提高代码的可维护性和扩展性。