详解java设计模式之六大原则

详解Java设计模式之六大原则

在软件开发中，设计模式是一种解决特定问题的经验总结，它提供了一种通用的设计思路，可以使我们在编码时更加高效和准确地解决问题。Java设计模式是指在Java程序开发中应用的一种设计方式，它有六大原则，分别是：

单一职责原则
里氏替换原则
依赖倒置原则
接口隔离原则
迪米特原则
开闭原则

本文将详细讲解这六大原则。

单一职责原则

单一职责原则是说一个类应该只有一个改变的原因。也就是说，如果一个类承担了多个职责，那么这个类就很容易出现问题，比如修改一个职责可能会影响另一个职责的正常使用。所以我们需要开发符合单一职责原则的类，使其功能单一，易于维护和扩展。

例如，我们有一个用户类，既要处理用户的登录功能，又要处理用户信息的增删改查，这样的设计就不符合单一职责原则。我们可以通过拆分为User、UserLogin、UserInfo三个类，使每个类只负责单一职责，更加清晰易懂。

class User {
    private UserLogin userLogin;
    private UserInfo userInfo;
}

class UserLogin { // 处理登录
    public void login() {
        // ...
    }
}

class UserInfo { // 处理用户信息的增删改查
    public void addUser() {
        // ...
    }
    public void removeUser() {
        // ...
    }
    public void updateUser() {
        // ...
    }
    public void getUserInfo() {
        // ...
    }
}

里氏替换原则

里氏替换原则是指子类可以替换父类并可正常使用。也就是说，在使用基类的地方可以用子类替换，而不影响程序的正确性。这一原则体现了继承关系的好处，即子类继承了父类的属性和方法，同时可以扩展自己的新功能。

例如，我们有两个类Bird和Penguin，其中Penguin是Bird的子类。在实际使用中，我们可以将Penguin对象替换为Bird对象，而不影响程序执行结果。

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

class Penguin extends Bird {
    public void swim() {
        System.out.println("I can swim");
    }
}

// 使用Bird替换Penguin
Bird bird = new Penguin();

依赖倒置原则

依赖倒置原则是指高层模块不应该依赖低层模块，它们都应该依赖它们的抽象。另外，抽象不应该依赖细节，而细节应该依赖抽象。这一原则有助于程序的扩展和维护。

例如，我们有一个电脑类，它依赖了一个鼠标类和一个键盘类。我们可以通过抽象出一个设备接口，使得高层模块的电脑类不直接依赖低层模块的鼠标类和键盘类，而是依赖设备接口。

interface Device {
    void work();
}

class Mouse implements Device {
    public void work() {
        System.out.println("Mouse works");
    }
}

class Keyboard implements Device {
    public void work() {
        System.out.println("Keyboard works");
    }
}

class Computer {
    private Device mouse;
    private Device keyboard;

    public Computer(Device mouse, Device keyboard) {
        this.mouse = mouse;
        this.keyboard = keyboard;
    }

    public void work() {
        mouse.work();
        keyboard.work();
        System.out.println("Computer works");
    }
}

接口隔离原则

接口隔离原则是指一个类不应该依赖它不需要的接口。接口应该拆分为更小、更具体的接口，这样使用接口的实现类就只需实现自己需要的接口方法，而不需要实现其他不需要的方法。

例如，我们有一个打印机接口，其中有打印、复印、扫描、传真等方法。如果我们直接让一个普通打印机实现这个接口，那么这个打印机需要实现所有方法，而很多方法并不需要。我们可以通过拆分成Print、Copy、Scan、Fax等接口，使得普通打印机只需要实现Print接口的打印方法。

interface Print {
    void print();
}

interface Copy {
    void copy();
}

interface Scan {
    void scan();
}

interface Fax {
    void fax();
}

class NormalPrinter implements Print {
    public void print() {
        System.out.println("Normal printer prints");
    }
}

class AdvancedPrinter implements Print, Scan, Fax {
    public void print() {
        System.out.println("Advanced printer prints");
    }

    public void scan() {
        System.out.println("Advanced printer scans");
    }

    public void fax() {
        System.out.println("Advanced printer faxes");
    }
}

迪米特原则

迪米特原则是指一个类不应该知道其他类太多的信息，它们之间应该保持最少的耦合。另外，一个类对外只公开它需要公开的方法，而不是所有的方法和属性。这一原则有助于使程序结构清晰，便于维护和扩展。

例如，我们有一个学校管理系统，其中包含了很多类，如学校、学生、教师、课程等。如果我们在学生类中直接访问教师类和课程类的方法，就会造成类之间的耦合。我们可以通过引入一个中介类（如管理类）来协调类之间的关系，并只公开需要公开的方法。

class School {
    private List<Student> students;
    private List<Teacher> teachers;
    private List<Course> courses;

    public School() {
        students = new ArrayList<>();
        teachers = new ArrayList<>();
        courses = new ArrayList<>();
    }

    public void addStudent(Student student) {
        students.add(student);
    }

    public void addTeacher(Teacher teacher) {
        teachers.add(teacher);
    }

    public void addCourse(Course course) {
        courses.add(course);
    }
}

class Student {
    private String name;
    private int age;

    public void getName() {
        System.out.println(name);
    }

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

    public void getAge() {
        System.out.println(age);
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// 在调用学生类时，只需要知道学生类的方法，不需要知道教师类和课程类的方法
School school = new School();
Student student = new Student();
school.addStudent(student);

开闭原则

开闭原则是指一个类应该对扩展开放，对修改关闭。也就是说，在修改一个类时，应该尽量避免直接修改它的代码。而是通过添加新的代码或者组合现有代码的方式来扩展功能。

例如，我们有一个打印机类，在打印文件的时候需要选择打印方式。如果我们在类中直接写入了打印方式的逻辑，那么在需要添加新的打印方式时就需要修改这个类的代码。我们可以通过使用策略模式，将打印方式的选择交给一个策略类来处理。

interface PrintStrategy {
    void print();
}

class PrintStrategy1 implements PrintStrategy {
    public void print() {
        System.out.println("Strategy 1 prints");
    }
}

class PrintStrategy2 implements PrintStrategy {
    public void print() {
        System.out.println("Strategy 2 prints");
    }
}

class Printer {
    private PrintStrategy printStrategy;

    public void setPrintStrategy(PrintStrategy printStrategy) {
        this.printStrategy = printStrategy;
    }

    public void print() {
        printStrategy.print();
    }
}

以上就是Java设计模式的六大原则的详细讲解。通过遵循这些原则，我们可以开发出逻辑清晰、易于维护、容易扩展的程序。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：详解java设计模式之六大原则 - Python技术站