Java设计模式七大原则是什么及怎么实现

目录

1. 引言
2. 单一职责原则
   • 定义
   • 实现
   • 示例
3. 开闭原则
   • 定义
   • 实现
   • 示例
4. 里氏替换原则
   • 定义
   • 实现
   • 示例
5. 接口隔离原则
   • 定义
   • 实现
   • 示例
6. 依赖倒置原则
   • 定义
   • 实现
   • 示例
7. 迪米特法则
   • 定义
   • 实现
   • 示例
8. 合成复用原则
   • 定义
   • 实现
   • 示例
9. 总结

引言

设计模式是软件开发中用于解决常见问题的可重用解决方案。Java设计模式七大原则是面向对象设计的基础，它们帮助开发者编写出可维护、可扩展和可重用的代码。本文将详细介绍这七大原则，并通过示例展示如何在Java中实现这些原则。

单一职责原则

定义

单一职责原则（Single Responsibility Principle, SRP）指出，一个类应该只有一个引起它变化的原因。换句话说，一个类应该只负责一项职责。

实现

为了实现单一职责原则，我们需要将类的职责分解为更小的、独立的类。每个类只负责一项具体的功能。

示例

// 违反单一职责原则的示例
class User {
    private String name;
    private String email;

    public void setName(String name) {
        this.name = name;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void saveUser() {
        // 保存用户信息到数据库
    }

    public void sendEmail() {
        // 发送邮件给用户
    }
}

// 遵循单一职责原则的示例
class User {
    private String name;
    private String email;

    public void setName(String name) {
        this.name = name;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

class UserRepository {
    public void saveUser(User user) {
        // 保存用户信息到数据库
    }
}

class EmailService {
    public void sendEmail(User user) {
        // 发送邮件给用户
    }
}

开闭原则

定义

开闭原则（Open/Closed Principle, OCP）指出，软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。这意味着我们应该能够在不修改现有代码的情况下扩展系统的行为。

实现

为了实现开闭原则，我们可以使用抽象类和接口来定义系统的行为，并通过继承或实现接口来扩展系统的功能。

示例

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

class AreaCalculator {
    public double calculateArea(Rectangle rectangle) {
        return rectangle.width * rectangle.height;
    }
}

// 遵循开闭原则的示例
interface Shape {
    double calculateArea();
}

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

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

class Circle implements Shape {
    public double radius;

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class AreaCalculator {
    public double calculateArea(Shape shape) {
        return shape.calculateArea();
    }
}

里氏替换原则

定义

里氏替换原则（Liskov Substitution Principle, LSP）指出，子类应该能够替换其父类并且不会影响程序的正确性。换句话说，子类应该扩展父类的行为，而不是改变父类的行为。

实现

为了实现里氏替换原则，我们需要确保子类在继承父类时，不会改变父类的行为。子类可以扩展父类的功能，但不能覆盖父类的行为。

示例

// 违反里氏替换原则的示例
class Bird {
    public void fly() {
        System.out.println("Flying");
    }
}

class Ostrich extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostrich cannot fly");
    }
}

// 遵循里氏替换原则的示例
class Bird {
    public void fly() {
        System.out.println("Flying");
    }
}

class Ostrich extends Bird {
    // Ostrich does not override fly method
}

class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow flying");
    }
}

接口隔离原则

定义

接口隔离原则（Interface Segregation Principle, ISP）指出，客户端不应该依赖于它们不使用的接口。换句话说，应该将大的接口拆分为更小的、更具体的接口，以便客户端只需要知道它们感兴趣的方法。

实现

为了实现接口隔离原则，我们需要将大的接口拆分为更小的、更具体的接口，确保每个接口只包含客户端需要的方法。

示例

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

class HumanWorker implements Worker {
    @Override
    public void work() {
        System.out.println("Human working");
    }

    @Override
    public void eat() {
        System.out.println("Human eating");
    }
}

class RobotWorker implements Worker {
    @Override
    public void work() {
        System.out.println("Robot working");
    }

    @Override
    public void eat() {
        throw new UnsupportedOperationException("Robot cannot eat");
    }
}

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

interface Eatable {
    void eat();
}

class HumanWorker implements Workable, Eatable {
    @Override
    public void work() {
        System.out.println("Human working");
    }

    @Override
    public void eat() {
        System.out.println("Human eating");
    }
}

class RobotWorker implements Workable {
    @Override
    public void work() {
        System.out.println("Robot working");
    }
}

依赖倒置原则

定义

依赖倒置原则（Dependency Inversion Principle, DIP）指出，高层模块不应该依赖于低层模块，两者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

实现

为了实现依赖倒置原则，我们需要使用抽象类或接口来定义系统的行为，并通过依赖注入等方式将具体的实现注入到高层模块中。

示例

// 违反依赖倒置原则的示例
class LightBulb {
    public void turnOn() {
        System.out.println("LightBulb turned on");
    }

    public void turnOff() {
        System.out.println("LightBulb turned off");
    }
}

class Switch {
    private LightBulb bulb;

    public Switch(LightBulb bulb) {
        this.bulb = bulb;
    }

    public void operate() {
        bulb.turnOn();
    }
}

// 遵循依赖倒置原则的示例
interface Switchable {
    void turnOn();
    void turnOff();
}

class LightBulb implements Switchable {
    @Override
    public void turnOn() {
        System.out.println("LightBulb turned on");
    }

    @Override
    public void turnOff() {
        System.out.println("LightBulb turned off");
    }
}

class Fan implements Switchable {
    @Override
    public void turnOn() {
        System.out.println("Fan turned on");
    }

    @Override
    public void turnOff() {
        System.out.println("Fan turned off");
    }
}

class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        device.turnOn();
    }
}

迪米特法则

定义

迪米特法则（Law of Demeter, LoD）指出，一个对象应该对其他对象有最少的了解。换句话说，一个类应该只与直接的朋友通信，而不与陌生人通信。

实现

为了实现迪米特法则，我们需要减少类之间的耦合，确保类只与直接的朋友通信，而不与陌生人通信。

示例

// 违反迪米特法则的示例
class Employee {
    private String name;
    private Department department;

    public Employee(String name, Department department) {
        this.name = name;
        this.department = department;
    }

    public Department getDepartment() {
        return department;
    }
}

class Department {
    private String name;
    private Manager manager;

    public Department(String name, Manager manager) {
        this.name = name;
        this.manager = manager;
    }

    public Manager getManager() {
        return manager;
    }
}

class Manager {
    private String name;

    public Manager(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class Company {
    public void printManagerName(Employee employee) {
        System.out.println(employee.getDepartment().getManager().getName());
    }
}

// 遵循迪米特法则的示例
class Employee {
    private String name;
    private Department department;

    public Employee(String name, Department department) {
        this.name = name;
        this.department = department;
    }

    public String getManagerName() {
        return department.getManagerName();
    }
}

class Department {
    private String name;
    private Manager manager;

    public Department(String name, Manager manager) {
        this.name = name;
        this.manager = manager;
    }

    public String getManagerName() {
        return manager.getName();
    }
}

class Manager {
    private String name;

    public Manager(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class Company {
    public void printManagerName(Employee employee) {
        System.out.println(employee.getManagerName());
    }
}

合成复用原则

定义

合成复用原则（Composite Reuse Principle, CRP）指出，尽量使用对象组合/聚合，而不是继承来达到复用的目的。通过组合/聚合，我们可以更灵活地复用代码，并且减少类之间的耦合。

实现

为了实现合成复用原则，我们需要优先使用组合/聚合来复用代码，而不是继承。通过组合/聚合，我们可以更灵活地复用代码，并且减少类之间的耦合。

示例

// 违反合成复用原则的示例
class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

class Car extends Engine {
    public void drive() {
        start();
        System.out.println("Car is driving");
    }
}

// 遵循合成复用原则的示例
class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

class Car {
    private Engine engine;

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

    public void drive() {
        engine.start();
        System.out.println("Car is driving");
    }
}

总结

Java设计模式七大原则是面向对象设计的基础，它们帮助开发者编写出可维护、可扩展和可重用的代码。通过遵循这些原则，我们可以提高代码的质量，减少代码的复杂性，并使代码更易于理解和维护。在实际开发中，我们应该根据具体情况灵活应用这些原则，以达到最佳的设计效果。