【设计模式学习笔记】七大原则『二』
设计模式是什么
在软件开发中，经过验证的，用于解决特定环境下、重复出现的、特定问题的解决方案。
设计模式七大原则
设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)
- 设计模式常用的七大原则
- 单一职责原则：一个类，一个方法只负责一件事。
- 接口隔离原则：使用专门的接口比使用单一的接口要好。
- 依赖倒转(倒置)原则：上层不能依赖于下层，他们都应该依赖于抽象。
- 里氏替换原则：在任何使用父类对象的地方，替换为子类对象以后，程序不会出现问题。
- 开闭原则：对扩展开放，修改关闭。
- 迪米特法则：最少知道原则。只和朋友通信。
- 合成复用原则：尽量使用聚合，依赖，组合等方法。
设计原则核心思想
- 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
- 针对接口编程，而不是针对实现编程。
- 为了交互对象之间的松耦合设计而努力
里式替换原则
基本介绍
子类可以替换父类，父类不能替换子类。只要父类能够出现的地方，子类就可以出现，而且替换为子类也不会产生任何的错误和异常，反之则不行。
- 子类必须完全实现父类的方法
- 子类可以有自己的属性和方法：子类替代父类传递到调用者中，子类的方法永远不会被调用。要想让子类方法被调用，必须通过重写方法实现。
应用实例
- 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。
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）原则是尽量使用合成/聚合的方式，而不是使用继承。
