设计模式七大设计原则Java 实践

1. 单一职责原则（Single Responsibility Principle, SRP）

单一职责原则规定一个类应该仅对一项职责负责。这意味着一个类应只关注一件事情，以便降低类之间的耦合度，提高代码的可维护性。

示例：

// 用户登录类
public class UserLogin {
    public boolean login(String username, String password) {
        // 登录逻辑
        return true;
    }
}

// 用户注册类
public class UserRegister {
    public void register(String username, String password) {
        // 注册逻辑
    }
}

通过将登录和注册分为两个独立的类，实现了单一职责原则。

2. 开闭原则（Open-Closed Principle, OCP）

开闭原则强调：对扩展开放，对修改关闭。这意味着在增加新功能时，应尽量通过扩展而非修改已有代码来实现。

示例：

// 支付接口
public interface Payment {
    void pay(double amount);
}

// 支付实现类
public class CreditCardPayment implements Payment {
    public void pay(double amount) {
        System.out.println("支付 " + amount + " 元通过信用卡完成。");
    }
}

public class BitcoinPayment implements Payment {
    public void pay(double amount) {
        System.out.println("支付 " + amount + " 元通过比特币完成。");
    }
}

新增支付方式时，只需实现 Payment 接口，而无需修改现有代码。

3. 里氏替换原则（Liskov Substitution Principle, LSP）

里氏替换原则指出，子类对象可以替换其父类对象而程序的行为保持不变。它确保了继承关系的正确性，避免因子类行为不同而破坏系统的稳定性。

示例：

// 父类
public class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getArea() {
        return width * height;
    }
}

// 子类
public class Square extends Rectangle {
    public void setWidth(int side) {
        this.width = this.height = side;
    }

    public void setHeight(int side) {
        this.width = this.height = side;
    }
}

确保子类 Square 不违背父类 Rectangle 的行为约定。

4. 接口隔离原则（Interface Segregation Principle, ISP）

接口隔离原则要求将大的接口拆分成多个小接口，以确保类只需要实现自己需要的功能。

示例：

// 拆分接口
public interface Printer {
    void print();
}

public interface Scanner {
    void scan();
}

// 多功能设备
public class MultiFunctionDevice implements Printer, Scanner {
    public void print() {
        System.out.println("打印文档");
    }

    public void scan() {
        System.out.println("扫描文档");
    }
}

通过拆分接口，类可以根据需要实现相关功能。

5. 依赖倒置原则（Dependency Inversion Principle, DIP）

依赖倒置原则强调高层模块不应依赖于低层模块，二者都应该依赖于抽象。

示例：

// 抽象支付接口
public interface Payment {
    void pay(double amount);
}

// 高层模块
public class Order {
    private Payment payment;

    public Order(Payment payment) {
        this.payment = payment;
    }

    public void process(double amount) {
        payment.pay(amount);
    }
}

通过依赖接口 Payment 而非具体实现，提高了模块间的灵活性。

6. 合成复用原则（Composite Reuse Principle, CRP）

合成复用原则提倡优先使用对象组合而非继承来实现功能复用。

示例：

// 技能接口
public interface Skill {
    void use();
}

public class Fireball implements Skill {
    public void use() {
        System.out.println("使用火球术");
    }
}

public class IceShield implements Skill {
    public void use() {
        System.out.println("使用冰盾");
    }
}

// 角色类
public class Character {
    private Skill skill;

    public Character(Skill skill) {
        this.skill = skill;
    }

    public void performSkill() {
        skill.use();
    }
}

通过组合技能对象，而非继承实现技能复用。

7. 迪米特法则（Law of Demeter, LoD）

迪米特法则要求一个对象应尽量少地了解其他对象，减少对象之间的直接耦合。

示例：

// 服务类
public class UserService {
    public String getUserName(int userId) {
        return "用户" + userId;
    }
}

// 订单类
public class Order {
    private UserService userService;

    public Order(UserService userService) {
        this.userService = userService;
    }

    public void printOrderDetails(int userId) {
        String userName = userService.getUserName(userId);
        System.out.println("订单属于: " + userName);
    }
}

通过服务类作为中介，避免直接与用户类交互。