面向对象设计原则与创建型模式解析
六大核心设计原则
单一职责原则（SRP） 一个类应仅承担一项明确职责。例如，在用户管理系统中，将数据存储逻辑与权限验证逻辑分离，分别由独立的类处理，提升代码可维护性。
开闭原则（OCP） 系统模块应支持扩展而不修改原有代码。通过抽象接口定义行为，具体实现通过继承或组合方式扩展，避免对已有逻辑进行直接更改。
依赖倒置原则（DIP） 高层组件不应依赖低层组件，两者均应依赖于抽象。即"依赖抽象而非具体实现"，从而降低模块间的耦合度，增强系统的灵活性。
里氏替换原则（LSP） 子类对象可以替代父类对象而程序行为不变。这意味着子类应在不破坏父类功能的前提下进行功能增强，禁止重写或改变父类已有行为。
接口隔离原则（ISP） 应避免定义庞大、冗余的接口。应根据实际使用需求，将接口拆分为多个小而专注的接口，使实现类只需关注其真正需要的方法。
迪米特法则（LOD） 一个类应尽量减少与其他类的直接交互。只与直接关联的对象通信，隐藏内部细节。例如，在部门管理中，应通过员工类提供的公共方法获取信息，而非直接访问其私有字段。
创建型设计模式
单例模式 确保某个类在整个应用中仅有一个实例，并提供全局访问点。
- 饿汉式：类加载时即创建实例，线程安全但资源可能提前占用。
- 懒汉式（同步）：首次调用时创建实例，使用 synchronized 保证线程安全。
- 枚举实现：利用枚举类型天然的唯一性，简洁且防反射、反序列化攻击。
简单工厂模式 通过一个统一的工厂类负责对象创建，客户端无需关心具体实现。适用于产品种类较少且相对固定的场景。
public interface Vehicle {
void start();
}
public class Car implements Vehicle {
@Override
public void start() {
System.out.println("Car engine started.");
}
}
public class Motorcycle implements Vehicle {
@Override
public void start() {
System.out.println("Motorcycle engine started.");
}
}
public class VehicleFactory {
public static Vehicle create(String type) {
switch (type.toLowerCase()) {
case "car": return new Car();
case "motorcycle": return new Motorcycle();
default: throw new IllegalArgumentException("Unknown vehicle type");
}
}
}
工厂方法模式 定义一个创建对象的接口，由子类决定实例化哪个类。适用于产品族结构复杂、未来可能新增类型的情况。
public abstract class VehicleFactory {
public abstract Vehicle createVehicle();
}
public class CarFactory extends VehicleFactory {
@Override
public Vehicle createVehicle() {
return new Car();
}
}
public class BikeFactory extends VehicleFactory {
@Override
public Vehicle createVehicle() {
return new Motorcycle();
}
}
抽象工厂模式 用于创建一组相关或相互依赖的产品族。通过抽象工厂接口统一管理多个产品的创建。
public interface ProductFactory {
Vehicle makeVehicle();
Accessory makeAccessory();
}
public class LuxuryVehicleFactory implements ProductFactory {
@Override
public Vehicle makeVehicle() {
return new Car();
}
@Override
public Accessory makeAccessory() {
return new PremiumAccessory();
}
}
建造者模式 用于构建复杂对象，将构造过程分步骤进行，支持灵活配置。特别适合参数多、可选属性丰富的场景。
public class Order {
private String customer;
private String product;
private int quantity;
private boolean express;
private Order(Builder builder) {
this.customer = builder.customer;
this.product = builder.product;
this.quantity = builder.quantity;
this.express = builder.express;
}
public static class Builder {
private String customer;
private String product;
private int quantity = 1;
private boolean express = false;
public Builder setCustomer(String customer) {
this.customer = customer;
return this;
}
public Builder setProduct(String product) {
this.product = product;
return this;
}
public Builder setQuantity(int quantity) {
this.quantity = quantity;
return this;
}
public Builder setExpress(boolean express) {
this.express = express;
return this;
}
public Order build() {
return new Order(this);
}
}
@Override
public String toString() {
return "Order{" +
"customer='" + customer + '\'' +
", product='" + product + '\'' +
", quantity=" + quantity +
", express=" + express +
'}';
}
}
原型模式 通过复制现有实例来创建新对象，避免重复初始化操作。适用于创建成本高或状态复杂的对象。
- 浅克隆：复制对象本身，引用类型仍指向原对象。
- 深克隆：递归复制所有嵌套对象，形成完全独立副本。
public abstract class Document implements Cloneable {
protected String title;
protected String content;
public abstract void display();
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 浅克隆
}
}
public class Report extends Document {
@Override
public void display() {
System.out.println("Displaying report: " + title);
}
}
