设计模式 1 核心基石#

设计模式不是玄学，是可复用的代码设计经验。所有设计模式的底层逻辑，都源于几套通用设计原则。掌握原则，就掌握了设计模式的核心精髓，无需死记硬背所有模式。

本文精简讲解SOLID五大原则+迪米特法则+组合优于继承+面向接口编程，搭配极简代码，易懂实用。

一、SOLID 五大核心原则#

1. 单一职责原则（SRP）#

定义：一个类/方法只负责一个职责，只有一个修改原因。
核心：杜绝臃肿类，拆分功能，降低耦合。

1
// 违背原则：一个类同时做用户保存和日志输出
2
class User {
3
    public void save(){}
4
    public void log(){}
5
}
6

7
// 遵循原则：职责拆分
8
class User {
9
    public void save(){}
10
}
11
class UserLog {
12
    public void log(){}
13
}

2. 开闭原则（OCP）#

定义：对扩展开放，对修改关闭。
核心：新增功能不改动原有代码，避免老代码出错。

1
// 违背：新增折扣功能需要修改原计算类
2
class Cashier {
3
    public double calcPrice(double original) {
4
        return original; // 原价
5
        // 新增折扣：需要在这里修改代码
6
    }
7
}
8

9
// 遵循：通过扩展实现新功能
10
interface Discount {
11
    double apply(double original);
12
}
13
class NormalDiscount implements Discount {
14
    public double apply(double original) {
15
        return original * 0.9;
16
    }
17
}
18
class VipDiscount implements Discount {
19
    public double apply(double original) {
20
        return original * 0.8;
21
    }
22
}

3. 里氏替换原则（LSP）#

定义：子类可以完全替换父类，且程序逻辑不受影响。
核心：子类不要重写父类非抽象方法，保证继承合法性。

1
// 违背：子类重写改变父类行为，无法替换
2
class Bird {
3
    void fly() { System.out.println("飞起来了"); }
4
}
5
class Ostrich extends Bird {
6
    // 鸵鸟不会飞，重写改变行为
7
    @Override
8
    void fly() { throw new RuntimeException(); }
9
}
10

11
// 遵循：提取抽象，保证行为一致性
12
interface Bird {}
13
interface FlyableBird extends Bird {
14
    void fly();
15
}
16
class Ostrich implements Bird {} // 不继承飞行能力
17
class Sparrow implements FlyableBird {
18
    public void fly() { System.out.println("飞起来了"); }
19
}

4. 接口隔离原则（ISP）#

定义：客户端不依赖不需要的接口，接口越小越精准。

1
// 臃肿接口（违背）
2
interface Animal {
3
    void run();
4
    void fly();
5
}
6

7
// 拆分细接口（遵循）
8
interface RunAnimal { void run(); }
9
interface FlyAnimal { void fly(); }

5. 依赖倒置原则（DIP）#

定义：依赖抽象接口，不依赖具体实现。
核心：解耦，实现代码灵活替换。

1
// 违背：依赖具体类
2
class MySQL { void save(){} }
3
class Service { MySQL db = new MySQL(); }
4

5
// 遵循：依赖抽象接口
6
interface DB { void save(); }
7
class MySQL implements DB { void save(){} }
8
class Service { DB db; }

二、三大补充黄金原则#

1. 迪米特法则（最少知道原则）#

定义：一个类尽量少依赖其他类，只和直接朋友通信。
核心：减少类之间的关联，降低代码牵一发动全身的风险。

1
// 违背：订单直接穿透多层，依赖仓库和商品
2
class Order {
3
    void create() {
4
        Warehouse warehouse = new Warehouse();
5
        Goods goods = warehouse.getGoods();
6
        goods.reduceStock(); // 直接操作内部对象
7
    }
8
}
9

10
// 遵循：只和直接朋友通信，让仓库自己处理
11
class Order {
12
    void create() {
13
        Warehouse warehouse = new Warehouse();
14
        warehouse.reduceGoodsStock(); // 只调用直接方法
15
    }
16
}

2. 组合优于继承#

核心：优先使用对象组合/聚合，少用类继承。
原因：继承是强耦合，父类改动会影响所有子类；组合灵活、可动态替换。

1
// 组合替代继承
2
class Engine { void start(){} }
3
class Car {
4
    // 组合复用功能
5
    private Engine engine = new Engine();
6
    public void run(){ engine.start(); }
7
}

3. 面向接口编程#

核心：定义抽象接口规范，实现类负责具体落地。
优势：屏蔽实现细节、统一调用规范、支持多实现动态切换，是Spring、多态的底层核心。

1
// 面向接口编程，灵活切换支付方式
2
interface PayChannel {
3
    boolean pay(double amount);
4
}
5

6
class AliPay implements PayChannel {
7
    public boolean pay(double amount) {
8
        // 支付宝实现
9
        return true;
10
    }
11
}
12

13
class WechatPay implements PayChannel {
14
    public boolean pay(double amount) {
15
        // 微信支付实现
16
        return true;
17
    }
18
}
19

20
// 调用方只依赖接口，不关心具体实现
21
class OrderService {
22
    private PayChannel payChannel;
23
    public void setPayChannel(PayChannel payChannel) {
24
        this.payChannel = payChannel; // 动态注入
25
    }
26
}