当前位置：首页 > news >正文

Java 面向对象设计的六大原则

news 2025/9/14 9:37:09

Java 面向对象设计的六大原则及示例

摘要

在大型 Java 项目中，代码的可维护性、可扩展性与复用性至关重要。
六大设计原则是面向对象设计的“金科玉律”，帮助开发者在需求变化时写出更稳健、易维护的代码。
本文将逐一介绍这六大原则，并提供简明 Java 示例。

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

一个类只做一件事。

含义：一个类应该只有一个引起它变化的原因。
好处：修改风险小，职责清晰。

示例：

// 只负责用户业务
public class UserService {public void createUser(String name) {System.out.println("Create user: " + name);}
}// 只负责日志记录
public class LogService {public void log(String msg) {System.out.println("[LOG] " + msg);}
}

2. 开闭原则（Open/Closed Principle）

对扩展开放，对修改关闭。

含义：新增功能时尽量通过扩展而非修改已有类。
好处：降低修改旧代码带来的风险。

示例：策略模式扩展支付方式

interface PaymentStrategy { void pay(double amount); }class Alipay implements PaymentStrategy {public void pay(double amount) { System.out.println("Alipay pay: " + amount); }
}class WeChatPay implements PaymentStrategy {public void pay(double amount) { System.out.println("WeChat pay: " + amount); }
}class PaymentService {private final PaymentStrategy strategy;public PaymentService(PaymentStrategy strategy) { this.strategy = strategy; }public void checkout(double amt) { strategy.pay(amt); }
}

新增支付方式只需实现 PaymentStrategy 接口。

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

子类必须能够替换父类出现的地方，并保持行为正确。

核心：遵守继承契约，避免破坏父类逻辑。

class Bird {public void fly() { System.out.println("I can fly"); }
}class Sparrow extends Bird {@Overridepublic void fly() { System.out.println("Sparrow flies swiftly"); }
}// 使用
Bird b = new Sparrow();
b.fly();

如果某个子类（如企鹅）不能飞，就不该继承 Bird，可以使用接口或组合代替。

4. 依赖倒置原则（Dependency Inversion Principle）

高层模块不依赖低层模块，两者都依赖抽象。

核心：面向接口编程，而不是面向实现。

interface UserRepository { void save(String user); }class JdbcUserRepository implements UserRepository {public void save(String user) { System.out.println("Save user: " + user); }
}class UserController {private final UserRepository repo;public UserController(UserRepository repo) { this.repo = repo; }public void register(String name) { repo.save(name); }
}

通过构造注入不同实现即可替换存储方式。

5. 接口隔离原则（Interface Segregation Principle）

客户端不应被迫依赖不需要的方法。

做法：多个小接口优于一个臃肿接口。

interface Flyable { void fly(); }
interface Swimmable { void swim(); }class Duck implements Flyable, Swimmable {public void fly() { System.out.println("Duck flies"); }public void swim() { System.out.println("Duck swims"); }
}class Fish implements Swimmable {public void swim() { System.out.println("Fish swims"); }
}

6. 迪米特法则（Law of Demeter / 最少知道原则）

一个对象应尽量少地了解其他对象的内部细节。

要点：只与“直接朋友”通信，避免过度依赖。

class Engine {void start() { System.out.println("Engine start"); }
}class Car {private final Engine engine = new Engine();public void start() { engine.start(); } // 封装细节
}class Driver {public void drive(Car car) {car.start();  // 不去 car.getEngine().start()}
}

总结

原则	关键词	作用
单一职责	一类一事	减少修改风险
开闭	扩展不修改	适应需求变化
里氏替换	子可替父	保持继承体系稳定
依赖倒置	依赖抽象	降低耦合
接口隔离	小而专	提高灵活性
迪米特	少知道	减少依赖链