Posted by 23 种设计模式按照 创建型、结构型、行为型 三类进行分类，每种模式包括定义、适用场景及 Java 代码示例。
一、创建型模式（Creational Patterns）
创建型模式用于 创建对象，它们提供了更灵活和可维护的对象创建方式。
1. 单例模式（Singleton Pattern）
定义：确保一个类只有一个实例，并提供一个全局访问点。
适用场景：
- 需要全局唯一对象，如数据库连接池、日志管理器、线程池等。
示例代码（懒汉式，线程安全）：
public class Singleton {
private static volatile Singleton instance;
private Singleton() {} // 私有构造方法，防止外部实例化
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
2. 工厂方法模式（Factory Method Pattern）
定义：定义一个创建对象的接口，让子类决定实例化哪一个类。
适用场景：
- 需要根据不同条件创建不同子类对象。
示例代码：
interface Product {
void use();
}
class ConcreteProductA implements Product {
public void use() {
System.out.println("使用产品A");
}
}
class ConcreteProductB implements Product {
public void use() {
System.out.println("使用产品B");
}
}
class Factory {
public static Product createProduct(String type) {
if (type.equals("A")) return new ConcreteProductA();
else if (type.equals("B")) return new ConcreteProductB();
return null;
}
}
public class FactoryMethodDemo {
public static void main(String[] args) {
Product product = Factory.createProduct("A");
product.use();
}
}
3. 抽象工厂模式（Abstract Factory Pattern）
定义：提供一个创建 相关或依赖对象 的接口，而无需指定具体类。
适用场景：
- 需要创建一系列 相关对象，如 GUI 组件（Windows / Mac ）。
示例代码：
interface Button {
void click();
}
class WindowsButton implements Button {
public void click() {
System.out.println("Windows 按钮");
}
}
class MacOSButton implements Button {
public void click() {
System.out.println("MacOS 按钮");
}
}
interface GUIFactory {
Button createButton();
}
class WindowsFactory implements GUIFactory {
public Button createButton() {
return new WindowsButton();
}
}
class MacOSFactory implements GUIFactory {
public Button createButton() {
return new MacOSButton();
}
}
public class AbstractFactoryDemo {
public static void main(String[] args) {
GUIFactory factory = new WindowsFactory();
Button button = factory.createButton();
button.click();
}
}
4. 建造者模式（Builder Pattern）
定义：将一个复杂对象的构建与表示分离，使同样的构建过程可以创建不同的表示。
适用场景：
- 需要创建复杂对象，但构建过程稳定，构建的各部分可能不同。
示例代码：
class Product {
private String partA;
private String partB;
public void setPartA(String partA) { this.partA = partA; }
public void setPartB(String partB) { this.partB = partB; }
public void show() {
System.out.println("Product built with: " + partA + " and " + partB);
}
}
class Builder {
private Product product = new Product();
public Builder buildPartA(String partA) {
product.setPartA(partA);
return this;
}
public Builder buildPartB(String partB) {
product.setPartB(partB);
return this;
}
public Product build() {
return product;
}
}
public class BuilderDemo {
public static void main(String[] args) {
Product product = new Builder().buildPartA("A1").buildPartB("B1").build();
product.show();
}
}
5. 原型模式（Prototype Pattern）
定义：通过复制已有对象来创建新对象，而不依赖构造函数。
适用场景：
- 需要快速创建对象，且避免构造过程的高开销。
示例代码：
class Prototype implements Cloneable {
private String field;
public Prototype(String field) { this.field = field; }
public void show() { System.out.println("Field: " + field); }
public Prototype clone() throws CloneNotSupportedException {
return (Prototype) super.clone();
}
}
public class PrototypeDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Prototype p1 = new Prototype("data");
Prototype p2 = p1.clone();
p2.show();
}
}
二、结构型模式（Structural Patterns）
结构型模式用于 组织类和对象，使系统更加灵活和可扩展。
- 适配器模式（Adapter Pattern）
- 桥接模式（Bridge Pattern）
- 组合模式（Composite Pattern）
- 装饰器模式（Decorator Pattern）
- 外观模式（Facade Pattern）
- 享元模式（Flyweight Pattern）
- 代理模式（Proxy Pattern）
三、行为型模式（Behavioral Patterns）
行为型模式用于 对象之间的交互，使系统更易扩展和维护。
- 责任链模式（Chain of Responsibility Pattern）
- 命令模式（Command Pattern）
- 解释器模式（Interpreter Pattern）
- 迭代器模式（Iterator Pattern）
- 中介者模式（Mediator Pattern）
- 备忘录模式（Memento Pattern）
- 观察者模式（Observer Pattern）
- 状态模式（State Pattern）
- 策略模式（Strategy Pattern）
- 模板方法模式（Template Method Pattern）
- 访问者模式（Visitor Pattern）