软件设计笔记(二) : 软件设计原则

开闭原则 (Open/Closed Principle)

定义：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

说明：通过使用接口和抽象类，可以在不修改现有代码的情况下扩展功能。

示例：

// 基础接口
interface Shape {
    double area();
}

// 扩展类：圆
class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double area() {
        return Math.PI * radius * radius;
    }
}

// 扩展类：矩形
class Rectangle implements Shape {
    private double width, height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return width * height;
    }
}

// 使用新的形状时不需要修改已有代码

单一职责原则 (Single Responsibility Principle)

定义：一个类应该只有一个引起其变化的原因。

说明：每个类都应该负责单一的功能。

示例：

// 职责：处理用户数据
class UserDataService {
    public void saveUserData(User user) {
        // 保存用户数据
    }
}

// 职责：发送通知
class NotificationService {
    public void sendEmail(User user) {
        // 发送电子邮件
    }
}

接口隔离原则 (Interface Segregation Principle)

定义：客户端不应该被强迫依赖于它不使用的方法。

说明：设计接口时，应尽量精简。

示例：

interface Printer {
    void printDocument();
}

interface Scanner {
    void scanDocument();
}

// 实现打印功能的类
class SimplePrinter implements Printer {
    public void printDocument() {
        // 打印文档
    }
}

// 实现扫描功能的类
class SimpleScanner implements Scanner {
    public void scanDocument() {
        // 扫描文档
    }
}

里氏替换原则 (Liskov Substitution Principle)

定义：子类对象能够替换父类对象，并且程序行为保持不变。

说明：子类不应改变父类的方法行为。

示例：

class Bird {
    public void fly() {
        System.out.println("Flying");
    }
}

class Sparrow extends Bird {
    // 继续保持飞行行为
}

class Penguin extends Bird {
    // 不用重写fly方法，以免违反里氏替换原则
    public void swim() {
        System.out.println("Swimming");
    }
}

依赖倒置原则 (Dependency Inversion Principle)

定义：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

说明：依赖接口或抽象类，而不是具体的类。

示例：

interface Keyboard {
    void type();
}

class MechanicalKeyboard implements Keyboard {
    public void type() {
        System.out.println("Typing on mechanical keyboard");
    }
}

class Computer {
    private Keyboard keyboard;

    public Computer(Keyboard keyboard) {
        this.keyboard = keyboard;
    }

    public void type() {
        keyboard.type();
    }
}

// 高层模块 (Computer) 依赖于抽象 (Keyboard) 而不是具体的类

合成复用原则 (Composition over Inheritance)

定义：优先使用组合而不是继承来实现功能复用。

说明：通过组合多个功能模块来实现新的功能。

示例：

class Engine {
    public void start() {
        System.out.println("Engine starting");
    }
}

class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }
}

// 使用组合而不是继承来实现Car的功能

迪米特法则 (Law of Demeter)

定义：一个对象应当对其他对象有尽可能少的了解。

说明：减少类之间的耦合，提高模块的独立性。

示例：

class Wheel {
    public void rotate() {
        System.out.println("Wheel rotating");
    }
}

class Car {
    private Wheel wheel = new Wheel();

    public void drive() {
        wheel.rotate(); // 只与自己的组件交互
    }
}

最后修改于 2024-06-02