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