设计模式的六大原则：
**单一职责原则：**就一个类而言，应该仅有一个引起它变化的原因。
**开放-封闭原则：**软件实体可以拓展但是不可以修改。
**依赖倒转原则：**高层模块和低层模块两者都应依赖抽象；抽象不应依赖细节，细节依赖抽象。
**里氏代换原则：**子类型必须能够替换掉它们的父类型。
**合成聚合复用原则：**尽量使用合成/聚合，尽量不要使用类继承。
**迪米特原则：**一个对象应该对其他对象保持最少的了解。不跟陌生人说话。
1. 工厂模式（Factory Pattern）
核心思想：通过工厂类统一创建对象，隐藏对象创建的细节，让使用者无需直接调用构造函数。
解决问题：
- 避免对象创建逻辑（如复杂初始化、依赖处理）分散在代码中，便于维护。
- 当需要更换对象类型时，只需修改工厂，无需改动所有使用处。
示例：
java
// 产品接口
interface Car {
void drive();
}
// 具体产品
class Benz implements Car {
@Override public void drive() { System.out.println("驾驶奔驰"); }
}
class BMW implements Car {
@Override public void drive() { System.out.println("驾驶宝马"); }
}
// 工厂类
class CarFactory {
// 根据类型创建对象
public static Car createCar(String type) {
if ("benz".equals(type)) return new Benz();
if ("bmw".equals(type)) return new BMW();
return null;
}
}
// 使用：无需直接new，通过工厂获取
Car car = CarFactory.createCar("benz");
car.drive();2. 责任链模式（Chain of Responsibility Pattern）
核心思想：将多个处理者组成一条链，请求沿链传递，直到某个处理者能处理为止。
解决问题：
- 避免请求发送者与多个处理者直接耦合（如请假审批：员工→组长→经理→总监，无需员工知道具体审批人）。
- 灵活调整处理者顺序或增减处理者。
示例：
java
// 处理者接口
abstract class Approver {
protected Approver next; // 下一个处理者
public Approver(Approver next) { this.next = next; }
abstract void approve(int days);
}
// 具体处理者
class TeamLeader extends Approver {
public TeamLeader(Approver next) { super(next); }
@Override void approve(int days) {
if (days <= 3) System.out.println("组长批准");
else next.approve(days); // 无法处理，交给下一个
}
}
class Manager extends Approver {
public Manager(Approver next) { super(next); }
@Override void approve(int days) {
if (days <= 7) System.out.println("经理批准");
else next.approve(days);
}
}
// 使用：构建责任链
Approver chain = new TeamLeader(new Manager(null));
chain.approve(5); // 经理批准3. 策略模式（Strategy Pattern）
核心思想：定义多种算法（策略），封装成独立类，使算法可动态切换。
解决问题：
- 避免大量
if-else或switch判断（如支付方式：支付宝、微信、银联，每种方式算法不同）。 - 算法可独立扩展，不影响使用方。
示例：
java
// 策略接口
interface PaymentStrategy {
void pay(double amount);
}
// 具体策略
class Alipay implements PaymentStrategy {
@Override public void pay(double amount) {
System.out.println("支付宝支付：" + amount);
}
}
class WechatPay implements PaymentStrategy {
@Override public void pay(double amount) {
System.out.println("微信支付：" + amount);
}
}
// 使用策略的类
class Order {
private PaymentStrategy strategy;
public Order(PaymentStrategy strategy) { this.strategy = strategy; }
public void pay(double amount) { strategy.pay(amount); }
}
// 使用：动态切换策略
Order order = new Order(new Alipay());
order.pay(100); // 支付宝支付
order = new Order(new WechatPay());
order.pay(200); // 微信支付4. 单例模式（Singleton Pattern）
核心思想 ：保证一个类在整个系统中只有一个实例，并提供全局访问点。
解决问题：
- 避免频繁创建销毁重量级对象（如配置管理器、线程池），节省资源。
- 确保全局状态一致性（如计数器、日志对象）。
示例（线程安全版）：
java
public class Singleton {
// 私有静态实例，volatile防止指令重排
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;
}
}
// 使用：全局唯一实例
Singleton obj1 = Singleton.getInstance();
Singleton obj2 = Singleton.getInstance();
System.out.println(obj1 == obj2); // true（同一实例）总结
| 模式 | 核心特点 | 典型场景 |
|---|---|---|
| 工厂模式 | 统一创建对象，隐藏创建细节 | 复杂对象初始化、产品族创建 |
| 责任链模式 | 请求沿处理者链传递，动态分工 | 审批流程、过滤器链、异常处理 |
| 策略模式 | 算法封装，动态切换 | 支付方式、排序算法、折扣计算 |
| 单例模式 | 全局唯一实例，节省资源 | 配置管理、日志对象、线程池 |
这些模式的核心是分离变化与不变，让系统更灵活、易维护。