六大原则随手拈来：手把手带你解锁设计模式

后端

2023-10-01 04:33:48

设计模式六大原则：掌控面向对象编程的精髓

什么是设计模式？

设计模式是面向对象编程中反复出现的可重用的解决方案。它们提供了一种经过验证的方法来解决常见编程问题，从而提高代码的可维护性、可扩展性和灵活性。

六大设计原则

遵循设计原则可以帮助你编写更优雅、更持久的代码。让我们来深入探讨六大设计原则：

1. 单一职责原则

这个原则规定，每个软件模块只应有一个明确的目的。将不同的职责分离到不同的模块中，可以使代码更容易理解和维护。

// 违反单一职责原则的示例
public class UserService {
    public void createUser(User user) {
        // 创建用户
    }

    public void updateUser(User user) {
        // 更新用户
    }

    public void deleteUser(User user) {
        // 删除用户
    }

    public User getUserById(int id) {
        // 根据 ID 获取用户
    }

    public List<User> getAllUsers() {
        // 获取所有用户
    }
}

// 遵循单一职责原则的示例
public class UserCreator {
    public void createUser(User user) {
        // 创建用户
    }
}

public class UserUpdater {
    public void updateUser(User user) {
        // 更新用户
    }
}

public class UserDeleter {
    public void deleteUser(User user) {
        // 删除用户
    }
}

public class UserGetter {
    public User getUserById(int id) {
        // 根据 ID 获取用户
    }

    public List<User> getAllUsers() {
        // 获取所有用户
    }
}

2. 开放-封闭原则

这个原则强调软件应易于扩展，而不必修改现有代码。通过使用抽象类和接口，你可以创建可扩展的代码，无需触及基础实现。

// 违反开放-封闭原则的示例
public class Rectangle {
    public double width;
    public double height;

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

// 遵循开放-封闭原则的示例
interface Shape {
    double getArea();
}

public class Rectangle implements Shape {
    public double width;
    public double height;

    @Override
    public double getArea() {
        return width * height;
    }
}

3. 里氏代换原则

这个原则规定，子类对象应该能够替换其父类对象，而不会破坏程序的正确性。这确保了代码的可扩展性和可重用性。

// 违反里氏代换原则的示例
public class Bird {
    public void fly() {
        // 飞翔
    }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        // 企鹅不会飞
    }
}

// 遵循里氏代换原则的示例
interface FlyingBird {
    void fly();
}

public class Bird implements FlyingBird {
    public void fly() {
        // 飞翔
    }
}

public class Penguin {
    // 企鹅不会飞
}

4. 接口隔离原则

这个原则规定，接口应尽可能精细，以避免强制客户端依赖它们不使用的功能。这有助于创建更松散耦合、更易于维护的代码。

// 违反接口隔离原则的示例
interface Animal {
    void eat();
    void sleep();
    void fly();
}

// 遵循接口隔离原则的示例
interface Eater {
    void eat();
}

interface Sleeper {
    void sleep();
}

interface Flyer {
    void fly();
}

5. 依赖倒置原则

这个原则强调高层模块不应依赖底层模块，而应依赖抽象。通过使用抽象类和接口，你可以创建一个更灵活、更易于测试的代码库。

// 违反依赖倒置原则的示例
public class Database {
    public void save(Object object) {
        // 保存对象到数据库
    }
}

public class UserService {
    private Database database;

    public UserService(Database database) {
        this.database = database;
    }

    public void saveUser(User user) {
        database.save(user);
    }
}

// 遵循依赖倒置原则的示例
interface DataStore {
    void save(Object object);
}

public class Database implements DataStore {
    public void save(Object object) {
        // 保存对象到数据库
    }
}

public class UserService {
    private DataStore dataStore;

    public UserService(DataStore dataStore) {
        this.dataStore = dataStore;
    }

    public void saveUser(User user) {
        dataStore.save(user);
    }
}

6. 合成复用原则

这个原则鼓励优先使用对象组合而不是继承来实现代码复用。这有助于创建更灵活、更可维护的代码。

// 违反合成复用原则的示例
public class Dog extends Animal {
    public void bark() {
        // 汪汪叫
    }
}

// 遵循合成复用原则的示例
public class Dog {
    private Animal animal;

    public Dog(Animal animal) {
        this.animal = animal;
    }

    public void bark() {
        animal.makeSound("汪汪");
    }
}