OOD原则|坚硬的

简介

OOD是Object Oriented Design(面向对象设计)的缩写，指的是在软件开发中使用面向对象的方法进行系统设计。而坚硬的则是指在软件开发过程中需要遵守一些规则和约定。在本文中，我们将探讨面向对象设计中的一些重要原则和坚持这些原则的重要性。

OOD原则

单一职责原则(Single Responsibility Principle, SRP)

该原则指的是一个类只负责一项职责。在一个类中出现多个职责会导致这个类变得难以理解和修改，也会使单元测试变得困难。

例如：

// 不符合单一职责原则
class Employee {
    public void calculateSalary() {
        // ...
    }
    public void saveToDatabase() {
        // ...
    }
}

// 符合单一职责原则
class Employee {
    public void calculateSalary() {
        // ...
    }
}
class DatabaseManager {
    public void saveToDatabase() {
        // ...
    }
}

开放-封闭原则(Open-Closed Principle, OCP)

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

例如：

// 不符合开放-封闭原则
class Employee {
    public void calculateSalary() {
        // ...
        if (isManager) {
            // ...
        } else {
            // ...
        }
    }
}

// 符合开放-封闭原则
class Employee {
    public void calculateSalary() {
        // ...
    }
}
class Manager extends Employee {
    public void calculateSalary() {
        // ...
    }
}

里氏替换原则(Liskov Substitution Principle, LSP)

该原则指的是子类可以替代父类进行使用，而不会影响程序的正确性。这意味着如果某个函数接受一个父类作为参数，那么它也应该接受子类作为参数。

例如：

// 不符合里氏替换原则
class Rectangle {
    private int width;
    private int height;
    public void setWidth(int width) {
        this.width = width;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public int getArea() {
        return width * height;
    }
}
class Square extends Rectangle {
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);
    }
    public void setHeight(int height) {
        super.setWidth(height);
        super.setHeight(height);
    }
}

// 符合里氏替换原则
interface Shape {
    int getArea();
}
class Rectangle implements Shape {
    private int width;
    private int height;
    public void setWidth(int width) {
        this.width = width;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public int getArea() {
        return width * height;
    }
}
class Square implements Shape {
    private int width;
    public void setWidth(int width) {
        this.width = width;
    }
    public int getArea() {
        return width * width;
    }
}

依赖倒置原则(Dependency Inversion Principle, DIP)

该原则指的是面向接口编程。高层模块不应该依赖低层模块，而是应该依赖它们共同依赖的抽象层。这意味着高层模块和低层模块都应该依赖于抽象层。

例如：

// 不符合依赖倒置原则
class Employee {
    private Database database;
    public void saveToDatabase() {
        database.save(this);
    }
}
class Database {
    public void save(Employee emp) {
        // ...
    }
}

// 符合依赖倒置原则
interface EmployeeRepository {
    void save(Employee emp);
}
class Employee {
    private EmployeeRepository repository;
    public void saveToDatabase() {
        repository.save(this);
    }
}
class DatabaseEmployeeRepository implements EmployeeRepository {
    public void save(Employee emp) {
        // ...
    }
}

接口隔离原则(Interface Segregation Principle, ISP)

该原则指的是不应该让客户端依赖它不需要的接口。接口应该根据客户端的需求进行划分。

例如：

// 不符合接口隔离原则
interface Employee {
    void calculateSalary();
    void updateInfo();
}

// 符合接口隔离原则
interface SalaryCalculator {
    void calculateSalary();
}
interface InfoUpdater {
    void updateInfo();
}

class Employee implements SalaryCalculator, InfoUpdater {
    // ...
}

迪米特法则(Law of Demeter, LoD)

该原则指的是一个对象应该对其他对象有尽可能少的了解。一个对象应该只和它的直接朋友交流。

例如：

// 不符合迪米特法则
class Company {
    private Department accounting;
    public void processPayroll() {
        accounting.calculatePayroll();
    }
}
class Department {
    private Employee[] employees;
    public void calculatePayroll() {
        for (Employee emp : employees) {
            // ...
        }
    }
}

// 符合迪米特法则
class Company {
    private PayrollCalculator calculator;
    public void processPayroll() {
        calculator.calculatePayroll();
    }
}
class PayrollCalculator {
    private EmployeeRepository repository;
    public void calculatePayroll() {
        List<Employee> employees = repository.findAll();
        for (Employee emp : employees) {
            // ...
        }
    }
}

坚守OOD原则的好处

坚守OOD原则可以使代码更加易读、易维护、易扩展、易测试。遵守OOD原则的代码通常更加模块化，减少了耦合，使得代码更加稳定可靠。

结论

OOD原则是面向对象设计的重要组成部分，遵守这些原则能够增加代码的可读性、可维护性、可扩展性、可测试性。在进行软件开发时，我们应该尽可能地坚守这些原则。