【设计模式学习笔记】七大原则『二』

设计模式是什么

　　在软件开发中，经过验证的，用于解决特定环境下、重复出现的、特定问题的解决方案。

设计模式七大原则

　　设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)

• 设计模式常用的七大原则
  • 单一职责原则：一个类，一个方法只负责一件事。
  • 接口隔离原则：使用专门的接口比使用单一的接口要好。
  • 依赖倒转(倒置)原则：上层不能依赖于下层，他们都应该依赖于抽象。
  • 里氏替换原则：在任何使用父类对象的地方，替换为子类对象以后，程序不会出现问题。
  • 开闭原则：对扩展开放，修改关闭。
  • 迪米特法则：最少知道原则。只和朋友通信。
  • 合成复用原则：尽量使用聚合，依赖，组合等方法。

设计原则核心思想

• 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
• 针对接口编程，而不是针对实现编程。
• 为了交互对象之间的松耦合设计而努力

里式替换原则

基本介绍

　　子类可以替换父类，父类不能替换子类。只要父类能够出现的地方，子类就可以出现，而且替换为子类也不会产生任何的错误和异常，反之则不行。

• 子类必须完全实现父类的方法
• 子类可以有自己的属性和方法：子类替代父类传递到调用者中，子类的方法永远不会被调用。要想让子类方法被调用，必须通过重写方法实现。

应用实例

• 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

public class Liskov {
    public static void main(String[] args) {
        A1 a1 = new A1();
        System.out.println("11 - 4 = " + a1.func1(11, 4));
        B1 b1 = new B1();
        System.out.println(b1.fun1(11, 4)); // 本意是调用父类的方法，但是子类重写了该方法
        System.out.println(b1.fun2(11, 4));
    }
}
class A1 {
    // 返回两个数的差
    public int func1 (int num1, int num2) {
        return num1 - num2;
    }
}
class B1 extends A1 {
    // 增加一个新的功能，完成两个数相加，然后求和
    public int fun1 (int a, int b) {
        return a + b;
    }
    public int fun2 (int a, int b) {
        return fun1(a, b) + 9;
    }
}

　　我们发现原来运行正常的相减功能发生了错误。原因就是类B无意中重写了父类的方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候。通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替。

• 继承的优缺点
  • 提高代码的重用性；提高代码的可扩展性。
  • 继承是侵入性的。只要有继承，就必须拥有父类的属性和方法。增强了耦合性。当父类被修改的时候，需要考虑子类的修改。

• 解决方案

public class Liskov {
    public static void main(String[] args) {
        A1 a1 = new A1();
        System.out.println("11 - 4 = " + a1.func1(11, 4));
        B1 b1 = new B1();
        System.out.println(b1.fun1(11, 4)); // B 类不在继承 A 类，因此调用者不会在认为 fun1 是减法
        System.out.println(b1.fun2(11, 4));

        // 使用组合仍然可以降低 A 类方法
        System.out.println("11 - 4 = " + b1.fun3(11, 4));
    }
}
// 创建增加基础的基类
class Base {
    // 把更加基础的方法和成员写到 Base 类中

}
class A1 extends Base {
    // 返回两个数的差
    public int func1 (int num1, int num2) {
        return num1 - num2;
    }
}
class B1 extends Base {
    private A1 a = new A1(); // 如果 B 需要 A 类的方法，使用组合关系

    // 增加一个新的功能，完成两个数相加，然后求和
    public int fun1 (int a, int b) {
        return a + b;
    }
    public int fun2 (int a, int b) {
        return fun1(a, b) + 9;
    }
    // 我们仍然想要使用 A 的方法
    public int fun3 (int a, int b) {
        return this.a.func1(a, b);
    }
}

使用场景

• 在类中调用其他类的时候，务必要使用父类的接口，否则说明类的设计就违背了里式替换原则。
• 如果子类不能完整的实现父类的方法，或者父类的某些方法在子类中已经发生了改变，则建议去掉原来的继承的关系，使用依赖、聚合、组合等关系来代替继承。

开闭原则

基本介绍

　　一个软件实体，如类，模块和函数应该对扩展开放，对修改关闭，也就是对提供方开放，对使用方关闭。使用抽象构建框架，实现扩展细节。当软件需要变化的时候，使用方尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。开闭原则是编程中最基础、最重要的设计原则。

• 绘制图形

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawCircle(new Circle());
    }
}

// 绘图的类
class GraphicEditor {
    // 绘制图形
    public void drawShape (Shape s) {
        if (s.m_type == 1) {
            drawRectangle(s);
        } else if (s.m_type == 2) {
            drawCircle(s);
        }
    }
    public void drawRectangle (Shape r) {
        System.out.println("矩形");
    }
    public void drawCircle (Shape c) {
        System.out.println("圆形");
    }
}

// 基类
class Shape {
    int m_type;
}

class Rectangle extends Shape {
    Rectangle () {
        super.m_type = 1;
    }
}

class Circle extends Shape {
    Circle () {
        super.m_type = 2;
    }
}

　　上面这段代码就违反了开闭原则，即对扩展开放，对修改关闭。当我们给类增加功能的时候，尽量不修改代码，或者尽量少修改代码。如果我们在这里新增加一个图形种类，那么此时需要修改的地方就比较多。

• 我们可以将Shape做成一个抽象类，提供一个抽象方法draw，这样让每一个类继承Shape，在实现功能的时候扩展抽象类中的方法。这样在进行修改的时候就不像上面那么复杂，只需要新建一个类继承Shape，然后实现相应的方法即可。

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

// 绘图的类
class GraphicEditor {
    // 绘制图形
    public void drawShape (Shape s) {
        s.draw();
    }
}

// 基类
abstract class Shape {
    int m_type;
    public abstract void draw();
}
class Rectangle extends Shape {
    Rectangle () {
        super.m_type = 1;
    }
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
class Circle extends Shape {
    Circle () {
        super.m_type = 2;
    }
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
class Triangle extends Shape {
    Triangle () {
        super.m_type = 3;
    }
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}
// 新增一个图形
class OtherGraphic extends Shape {

    @Override
    public void draw() {
        System.out.println("绘制其他图形");
    }
}

迪米特法则

基本介绍

• 迪米特法则(DemeterPrinciple)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。
• 迪米特法则还有个更简单的定义：只与直接的朋友通信。
• 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

应用实例

• 打印一个学校所有员工的信息，包含学校总部员工，学校学院员工

// 客户端
public class Demeter {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}
// 学校总部员工类
class Employee {
    private String id;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
// 学院员工类
class CollegeEmployee {
    private String id;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
// 管理学院员工的管理类
class CollegeManager {
    // 返回学院所有员工
    public List<CollegeEmployee> getAllEmployee () {
        List<CollegeEmployee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工 id = " + i);
            list.add(emp);
        }
        return list;
    }
}
// 学校管理类
// SchoolManager 直接朋友：Employee CollegeManager
// CollegeEmployee 不是直接朋友，违背了迪米特原则
class SchoolManager {
    // 返回学校总部的员工
    public List<Employee> getAllEmployee () {
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Employee employee = new Employee();
            employee.setId("学校员工 id = " + i);
            list.add(employee);
        }
        return list;
    }
    // 输出学校总部和学院员工信息的方法
    void printAllEmployee (CollegeManager collegeManager) {
        // CollegeEmployee 以局部变量的方式出现在 SchoolManager 中，违反了迪米特法则
        List<CollegeEmployee> list = collegeManager.getAllEmployee();
        System.out.println("==============学院员工信息==============");
        for (CollegeEmployee collegeEmployee : list) {
            System.out.println(collegeEmployee.getId());
        }
        List<Employee> allEmployee = this.getAllEmployee();
        System.out.println("==============学校总部员工信息=============");
        for (Employee employee : allEmployee) {
            System.out.println(employee.getId());
        }
    }
}

　　上述代码中违反了迪米特法则，CollegeEmployee不是CollegeManager的直接朋友，按照迪米特法则，不应该出现非直接朋友关系这样的耦合。

• 解决方案

// 客户端
public class Demeter {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}
// 学校总部员工类
class Employee {
    private String id;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
// 学院员工类
class CollegeEmployee {
    private String id;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
// 管理学院员工的管理类
class CollegeManager {
    // 返回学院所有员工
    public List<CollegeEmployee> getAllEmployee () {
        List<CollegeEmployee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工 id = " + i);
            list.add(emp);
        }
        return list;
    }
    void printAEmployee() {
        List<CollegeEmployee> list = this.getAllEmployee();
        System.out.println("==============学院员工信息=============");
        for (CollegeEmployee collegeEmployee : list) {
            System.out.println(collegeEmployee.getId());
        }
    }
}
// 学校管理类
// SchoolManager 直接朋友：Employee CollegeManager
// CollegeEmployee 不是直接朋友，违背了迪米特原则
class SchoolManager {
    // 返回学校总部的员工
    public List<Employee> getAllEmployee () {
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Employee employee = new Employee();
            employee.setId("学校员工 id = " + i);
            list.add(employee);
        }
        return list;
    }
    // 输出学校总部和学院员工信息的方法
    void printAllEmployee (CollegeManager collegeManager) {
        // 输出学院的员工的方法封装到 CollegeManager 中
        collegeManager.printAEmployee();
        List<Employee> allEmployee = this.getAllEmployee();
        System.out.println("==============学校总部员工信息=============");
        for (Employee employee : allEmployee) {
            System.out.println(employee.getId());
        }
    }
}

迪米特法则注意事项和细节

• 迪米特法则的核心是降低类之间的耦合，提高类的复用率。
• 但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间(对象间)耦合关系，并不是要求完全没有依赖关系。

合成复用原则

• 合成复用原则（CompositeReusePrinciple）原则是尽量使用合成/聚合的方式，而不是使用继承。