Java程序员应当知道的10个面向对象设计原则(Java程序员必知的10大面向对象设计原则)

原创

ithorizon 6个月前 (10-21) 阅读数 35 #后端开发

Java程序员必知的10大面向对象设计原则

一、单一职责原则（Single Responsibility Principle）

单一职责原则指的是一个类应该只负责一项职责。如果一个类承担了多项职责，那么它就违反了单一职责原则。这样做的好处是促使类更容易懂得和维护。


public class Order {
    private Customer customer;
    private List orderLines;
    public void addOrderLine(OrderLine orderLine) {
        orderLines.add(orderLine);
    }
    public void removeOrderLine(OrderLine orderLine) {
        orderLines.remove(orderLine);
    }
    // 其他与订单相关的操作
}
public class Customer {
    private String name;
    private String email;
    // 与客户相关的操作
}

二、开闭原则（Open-Closed Principle）

开闭原则指的是软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这意味着一个实体允许其功能通过添加新的代码来扩展，而不是通过修改已有代码来扩展。


public abstract class Shape {
    public abstract void draw();
}
public class Circle extends Shape {
    @Override
    public void draw() {
        // 绘制圆形
    }
}
public class Rectangle extends Shape {
    @Override
    public void draw() {
        // 绘制矩形
    }
}

三、里氏替换原则（Liskov Substitution Principle）

里氏替换原则指的是子类可以替换其父类，而不会造成程序出现差错。这意味着子类应该能够继承父类的行为，并且可以在任何父类出现的地方替换父类。


public abstract class Animal {
    public abstract void makeSound();
}
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪！");
    }
}
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵！");
    }
}

四、依赖性倒置原则（Dependency Inversion Principle）

依赖性倒置原则指的是高层模块不应该依赖性于低层模块，二者都应该依赖性于抽象。抽象不应该依赖性于细节，细节应该依赖性于抽象。这样可以降低模块间的耦合度。


public interface Food {
    void eat();
}
public class FastFood implements Food {
    @Override
    public void eat() {
        System.out.println("吃快餐");
    }
}
public class Restaurant {
    private Food food;
    public Restaurant(Food food) {
        this.food = food;
    }
    public void serve() {
        food.eat();
    }
}

五、接口隔离原则（Interface Segregation Principle）

接口隔离原则指的是多个特定客户端接口要好于一个宽泛用途的接口。客户端不应该被迫实现它们不需要的接口。


public interface Machine {
    void start();
    void stop();
    void execute();
}
public interface UserInterface {
    void turnOn();
    void turnOff();
}
public class CoffeeMachine implements Machine {
    @Override
    public void start() {
        // 启动咖啡机
    }
    @Override
    public void stop() {
        // 停止咖啡机
    }
    @Override
    public void execute() {
        // 制作咖啡
    }
}
public class UserInterfaceMachine implements UserInterface {
    @Override
    public void turnOn() {
        // 打开设备
    }
    @Override
    public void turnOff() {
        // 关闭设备
    }
}

六、迪米特法则（Law of Demeter）

迪米特法则，又称为最少知识原则，指的是一个对象应该对其他对象有尽也许少的了解。也就是说，一个对象应该只与直接相关的对象通信。


public class Teacher {
    private List students;
    public void notifyStudents() {
        for (Student student : students) {
            student.notify();
        }
    }
}
public class Student {
    public void notify() {
        // 通知学生
    }
}

七、组合优于继承（Composition over Inheritance）

组合优于继承原则指的是在面向对象设计中，通过组合关系来构建类，而不是通过继承关系。组合关系可以促使代码更加灵活和可复用。


public class Engine {
    public void start() {
        // 启动引擎
    }
}
public class Car {
    private Engine engine;
    public void start() {
        engine.start();
    }
}
public class Bicycle {
    private Engine engine;
    public void start() {
        engine.start();
    }
}

八、共同闭包原则（Common Closure Principle）

共同闭包原则指的是如果两个类由于相同的理由需要同时修改，那么它们应该被封装在一起。这样可以降低因修改而造成的副作用。


public class Database {
    private Connection connection;
    public Database(Connection connection) {
        this.connection = connection;
    }
    public void query(String sql) {
        // 执行查询
    }
}
public class Connection {
    private String url;
    private String username;
    private String password;
    public Connection(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }
    public void connect() {
        // 连接数据库
    }
}

九、共同复用原则（Common Reuse Principle）

共同复用原则指的是一个包中的类应该被一起复用。如果类A被包B中的类C依赖性，那么包B中的其他类也应该能够使用类A，否则就违反了共同复用原则。


public class MathUtil {
    public static int add(int a, int b) {
        return a + b;
    }
}
public class GeometryUtil {
    public static double calculateArea(Circle circle) {
        return Math.PI * circle.getRadius() * circle.getRadius();
    }
}
public class UtilPackage {
    public static void main(String[] args) {
        int sum = MathUtil.add(5, 10);
        double area = GeometryUtil.calculateArea(new Circle(5));
    }
}

十、最小化依赖性原则（Minimize Dependency Principle）

最小化依赖性原则指的是在依赖性关系中，尽量减少类之间的依赖性。这样可以降低系统的复杂化度和耦合度，减成本时间系统的可维护性。


public interface Logger {
    void log(String message);
}
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 将日志写入文件
    }
}
public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        // 将日志写入数据库
    }
}
public class App {
    private Logger logger;
    public App(Logger logger) {
        this.logger = logger;
    }
    public void doSomething() {
        // 执行操作
        logger.log("操作完成");
    }
}