第二章 设计模式七大原则

---

---

前言

---

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

1、单一职责原则 ，2、 接口隔离原则，3、依赖倒转(倒置)原则，4、里氏替换原则，5、开闭原则，6、 迪米特法则，7、 合成复用原则

一、单一职责 🍧

对类来说的，即一个类应该只负责一项职责。如类A 负责两个不同职责: 职责 1，职责 2。当职责1需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2。

例如我们平常用来操作数据库的实体类，每个实体类都对应着一张表，这就体现出了单一职责的各司其职。controller和service也都是一一对应各司其职，也是单一职责的表现

1、单一职责原则注意事项和细节

1. 降低类的复杂度，一个类只负责一项职责。
2. 提高类的可读性，可维护性
3. 降低变更引起的风险
4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

2、代码实现

2、1 错误示例

public class SingleResponsibility1 {public static void main(String[]{Vehicle vehicle = new Vehicle();vehicle.run("摩托车");vehicle.run("汽车");vehicle.run("飞机");}
}// 交通工具类
// 方式 1
// 1. 在方式 1 的 run 方法中，违反了单一职责原则
// 2. 解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可
class Vehicle {public void run(String vehicle) {System.out.println(vehicle + " 在公路上运行....");}
}

2、2 正确示例但有缺陷

public class SingleResponsibility2 {public static void main(String[] args){RoadVehicle roadVehicle = new RoadVehicle();roadVehicle.run("摩托车");roadVehicle.run("汽车");AirVehicle airVehicle = new AirVehicle();airVehicle.run("飞机");}
}//方案 2 的分析
//1. 遵守单一职责原则
//2. 但是这样做的改动很大，即将类分解，同时修改客户端
//3. 改进：直接修改 Vehicle 类，改动的代码会比较少=>方案 3
class RoadVehicle {public void run(String vehicle) {System.out.println(vehicle + "公路运行");}
}class AirVehicle {public void run(String vehicle) {System.out.println(vehicle + "天空运行");}
}class WaterVehicle {public void run(String vehicle) {System.out.println(vehicle + "水中运行");}
}

2、3 最终形态

public class SingleResponsibility3 {public static void main(String[] args) {Vehicle2 vehicle2 = new Vehicle2();vehicle2.run("汽车");vehicle2.runWater("轮船");vehicle2.runAir("飞机");}
}//方式 3的分析//1. 这种修改方法没有对原来的类做大的修改，只是增加方法
//2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责
class Vehicle2 {public void run(String vehicle) {//处理System.out.println(vehicle + " 在公路上运行....");}public void runAir(String vehicle) {System.out.println(vehicle + " 在天空上运行....");}public void runWater(String vehicle) {System.out.println(vehicle + " 在水中行....");}}

二、接口隔离原则 🥩

1、代码示例

package shejimoshi;public class test1 {public static void main(String[] args) {
// TODO Auto-generated method stub
// 使用一把A a = new A();a.depend1(new B()); // A 类通过接口去依赖 B 类a.depend2(new B());a.depend3(new B());C c = new C();c.depend1(new D()); // C 类通过接口去依赖(使用)D 类c.depend4(new D());c.depend5(new D());}}// 接口 1
interface Interface1 {void operation1();
}
// 接口 2
interface Interface2 {void operation2();void operation3();
}
// 接口 3
interface Interface3 {void operation4();void operation5();
}class B implements Interface1, Interface2 {@Overridepublic void operation1() {System.out.println("B 实现了 operation1");}@Overridepublic void operation2() {System.out.println("B 实现了 operation2");}@Overridepublic void operation3() {System.out.println("B 实现了 operation3");}
}class D implements Interface1, Interface3 {@Overridepublic void operation1() {System.out.println("D 实现了 operation1");}@Overridepublic void operation4() {System.out.println("D 实现了 operation4");}@Overridepublic void operation5() {System.out.println("D 实现了 operation5");}
}class A { // A 类通过接口 Interface1,Interface2 依赖(使用) B 类，但是只会用到 1,2,3 方法public void depend1(Interface1 i) {i.operation1();}public void depend2(Interface2 i) {i.operation2();}public void depend3(Interface2 i) {i.operation3();}
}
class C { // C 类通过接口 Interface1,Interface3 依赖(使用) D 类，但是只会用到 1,4,5 方法public void depend1(Interface1 i) {i.operation1();}public void depend4(Interface3 i) {i.operation4();}public void depend5(Interface3 i) {i.operation5();}
}输出
B 实现了 operation1
B 实现了 operation2
B 实现了 operation3
D 实现了 operation1
D 实现了 operation4
D 实现了 operation5

三、依赖倒转原则 🥥

1、代码示例

正常代码，没有加入设计模式

//完成 Person 接收消息的功能
//方式 1 分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时 Perons 也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
// 因为 Email, WeiXin 等等属于接收的范围，他们各自实现 IReceiver 接口就 ok, 这样我们就符合依赖倒转原则

package shejimoshi;public class test2 {public static void main(String[] args) {Person person = new Person();person.receive(new Email());}}class Email {public String getInfo() {return "电子邮件信息: hello,world";}
}//完成 Person 接收消息的功能
//方式 1 分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时 Perons 也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
// 因为 Email, WeiXin 等等属于接收的范围，他们各自实现 IReceiver 接口就 ok, 这样我们就符合依赖倒转原则
class Person {public void receive(Email email ) {System.out.println(email.getInfo());}
}输出
电子邮件信息: hello,world

加入设计模式，依赖倒转原则

package shejimoshi;public class test2 {public static void main(String[] args) {//客户端无需改变Person person = new Person();person.receive(new Email());person.receive(new WeiXin());}}//定义接口
interface IReceiver {public String getInfo();
}//增加微信
class WeiXin implements IReceiver {public String getInfo() {return "微信信息: hello,ok";}
}class Email implements IReceiver {public String getInfo() {return "电子邮件信息: hello,world";}
}class Person {public void receive(IReceiver iReceiver ) {System.out.println(iReceiver.getInfo());}
}输出
电子邮件信息: hello,world
微信信息: hello,ok

2、依赖关系传递的三种方式

三种方式代码示例

package shejimoshi;public class DependencyPass {public static void main(String[] args) {
// TODO Auto-generated method stubChangHong changHong = new ChangHong();OpenAndClose openAndClose = new OpenAndClose();openAndClose.open(changHong);//通过构造器进行依赖传递
//         OpenAndClose openAndClose = new OpenAndClose(changHong);
//         openAndClose.open();//通过 setter 方法进行依赖传递
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.setTv(changHong);
//        openAndClose.open();}
}// 方式 1： 通过接口传递实现依赖
// 开关的接口interface IOpenAndClose {public void open(ITV tv); //抽象方法,接收接口
}interface ITV { //ITV 接口public void play();
}//class ChangHong implements ITV {
//
//    @Override
//    public void play() {
//        // TODO Auto-generated method stub
//        System.out.println("长虹电视机，打开");
//    }
//
//}
// 实现接口
class OpenAndClose implements IOpenAndClose{public void open(ITV tv){tv.play();}
}
// 方式 2: 通过构造方法依赖传递
//interface IOpenAndClose {
//    public void open(); //抽象方法
//}
//interface ITV { //ITV 接口
//    public void play();
//}
//class OpenAndClose implements IOpenAndClose{
//    public ITV tv; //成员
//    public OpenAndClose(ITV tv){ //构造器
//        this.tv = tv;
//    }
//    public void open(){
//        this.tv.play();
//    }
//}
// 方式 3 , 通过 setter 方法传递
//interface IOpenAndClose {
//    public void open(); // 抽象方法
//    public void setTv(ITV tv);
//}
//interface ITV { // ITV 接口
//    public void play();
//}
//class OpenAndClose implements IOpenAndClose {
//    private ITV tv;
//    public void setTv(ITV tv) {
//        this.tv = tv;
//    }
//    public void open() {
//        this.tv.play();
//    }
//}
class ChangHong implements ITV {@Overridepublic void play() {
// TODO Auto-generated method stubSystem.out.println("长虹电视机，打开");}
}

四、里氏替换原则 🍇

我们在写代码的平常，很多地方会用到继承，这大大便利了我们程序的便利，但也带来了很多弊端，父类的修改可能会造成子类的故障，子类继承父类重写父类的方法后，如果父类进行了修改，就会对继承体系造成一些不可预知的侵入性，这时我们尽量不让子类去重写父类的方法，而是将子类和父类设计为兄长类，平起平坐，把两个类公共的方法抽象成一个抽象类，两个类都去继承抽象类，这样都具有了相同的行为，而一些特有的行为也不会影响到对方。

问题的引出：子类无意间重写了父类的方法导致业务逻辑发生错误

package shejimoshi;public class Liskov {public static void main(String[] args) {
// TODO Auto-generated method stubA a = new A();System.out.println("11-3=" + a.func1(11, 3));System.out.println("1-8=" + a.func1(1, 8));System.out.println("-----------------------");B b = new B();//这里本意是求出 11-3, 但由于子类不经意间重写了父类的方法，从而产生了不可预知的错误System.out.println("11-3=" + b.func1(11, 3));System.out.println("1-8=" + b.func1(1, 8));// 1-8System.out.println("11+3+9=" + b.func2(11, 3));}
}// A 类
class A {// 返回两个数的差public int func1(int num1, int num2) {return num1 - num2;}
}
// B 类继承了 A
// 增加了一个新功能：完成两个数相加,然后和 9 求和
class B extends A {//这里，重写了 A 类的方法, 可能是无意识public int func1(int a, int b) {return a + b;}public int func2(int a, int b) {return func1(a, b) + 9;}
}

解决方案：继承同一基类，使用组合

package shejimoshi;public class Liskov {public static void main(String[] args) {
// TODO Auto-generated method stubA a = new A();System.out.println("11-3=" + a.func1(11, 3));System.out.println("1-8=" + a.func1(1, 8));System.out.println("-----------------------");B b = new B();System.out.println("11-3=" + b.func1(11, 3));//这里本意是求出 11-3System.out.println("1-8=" + b.func1(1, 8));// 1-8System.out.println("11+3+9=" + b.func2(11, 3));System.out.println("---------使用组合后");//使用组合仍然可以使用到 A 类相关方法System.out.println("11-3=" + b.func3(11, 3));// 这里本意是求出 11-}
}//创建一个更加基础的基类
class Base {//把更加基础的方法和成员写到 Base 类public int func1(int num1, int num2) {return num1 - num2;}
}
// A 类
class A extends Base {// 返回两个数的差public int func1(int num1, int num2) {return num1 - num2;}
}
// B 类继承了 A
// 增加了一个新功能：完成两个数相加,然后和 9 求和
class B extends Base {//如果 B 需要使用 A 类的方法,使用组合关系private A a = new A();//这里，重写了 A 类的方法, 可能是无意识public int func1(int a, int b) {return a + b;}public int func2(int a, int b) {return func1(a, b) + 9;}//我们仍然想使用 A 的方法public int func3(int a, int b) {return this.a.func1(a, b);}
}输出11-3=8
1-8=-7
-----------------------
11-3=14
1-8=9
11+3+9=23
---------使用组合后
11-3=8

五、开闭原则 🐷

方式1

package tanchishell.SJMS.ocp;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());}
}//这是一个用于绘图的类 [使用方]
class GraphicEditor {//接收 Shape 对象，然后根据 type，来绘制不同的图形public void drawShape(Shape s) {if (s.m_type == 1)drawRectangle(s);else if (s.m_type == 2)drawCircle(s);else if (s.m_type == 3)drawTriangle(s);}//绘制矩形public void drawRectangle(Shape r) {System.out.println(" 绘制矩形 ");}//绘制圆形public void drawCircle(Shape r) {System.out.println(" 绘制圆形 ");}//绘制三角形public void drawTriangle(Shape r) {System.out.println(" 绘制三角形 ");}
}//Shape 类，基类
class Shape {int m_type;
}class Rectangle extends Shape {Rectangle() {super.m_type = 1;}
}class Circle extends Shape {Circle() {super.m_type = 2;}
}//新增画三角形
class Triangle extends Shape {Triangle() {super.m_type = 3;}
}输出绘制矩形 绘制圆形 绘制三角形 

方式 1 的缺点

1. 优点是比较好理解，简单易操作。
2. 缺点是违反了设计模式的 ocp 原则，即对扩展开放(提供方)，对修改关闭(使用方)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
3. 比如我们这时要新增加一个图形种类 三角形，我们需要做如下修改，修改的地方较多

方式2 进行改进

思路：把创建 Shape 类做成抽象类，并提供一个抽象的 draw 方法，让子类去实现即可，这样我们有新的图形 种类时，只需要让新的图形类继承 Shape，并实现 draw 方法即可，使用方的代码就不需要修 -> 满足了开闭原

package tanchishell.SJMS.ocp;public class ocp2 {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 {//接收 Shape 对象，调用 draw 方法public void drawShape(Shape s) {s.draw();}
}//Shape 类，基类
abstract class Shape {int m_type;public abstract void draw();//抽象方法
}
class Rectangle extends Shape {Rectangle() {super.m_type = 1;}@Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println(" 绘制矩形 ");}
}
class Circle extends Shape {Circle() {super.m_type = 2;}@Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println(" 绘制圆形 ");}
}//新增画三角形
class Triangle extends Shape {Triangle() {super.m_type = 3;}@Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println(" 绘制三角形 ");}
}
//新增一个图形
class OtherGraphic extends Shape {OtherGraphic() {super.m_type = 4;}@Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println(" 绘制其它图形 ");}
}输出绘制矩形 绘制圆形 绘制三角形 绘制其它图形 

六、迪米特法则 🌍

非直接关系的朋友对象，应该在该对象内部实现业务逻辑，暴露给外部一个 public 的引用，来避免对象间的耦合

错误示例

package tanchishell.SJMS.demeter;import java.util.ArrayList;
import java.util.List;//客户端
public class Demeter1 {public static void main(String[] args) {
//创建了一个 SchoolManager 对象SchoolManager schoolManager = new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息schoolManager.printAllEmployee(new CollegeManager());}
}//学校总部员工类
class Employee {private String id;public void setId(String id) {this.id = id;}public String getId() {return id;}
}//学院的员工类
class CollegeEmployee {private String id;public void setId(String id) {this.id = id;}public String getId() {return id;}
}//管理学院员工的管理类
class CollegeManager {//返回学院的所有员工public List<CollegeEmployee> getAllEmployee() {List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();for (int i = 0; i < 10; i++) { //这里我们增加了 10 个员工到 listCollegeEmployee 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<Employee>();for (int i = 0; i < 5; i++) { //这里我们增加了 5 个员工到 listEmployee emp = new Employee();emp.setId("学校总部员工 id= " + i);list.add(emp);}return list;}//该方法完成输出学校总部和学院员工信息(id)void printAllEmployee(CollegeManager sub) {
//分析问题
//1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
//3. 违反了 迪米特法则
//获取到学院员工List<CollegeEmployee> list1 = sub.getAllEmployee();System.out.println("------------学院员工------------");for (CollegeEmployee e : list1) {System.out.println(e.getId());}
//获取到学校总部员工List<Employee> list2 = this.getAllEmployee();System.out.println("------------学校总部员工------------");for (Employee e : list2) {System.out.println(e.getId());}}
}输出------------学院员工------------
学院员工 id= 0
学院员工 id= 1
学院员工 id= 2
学院员工 id= 3
学院员工 id= 4
学院员工 id= 5
学院员工 id= 6
学院员工 id= 7
学院员工 id= 8
学院员工 id= 9
------------学校总部员工------------
学校总部员工 id= 0
学校总部员工 id= 1
学校总部员工 id= 2
学校总部员工 id= 3
学校总部员工 id= 4

正确示例

package tanchishell.SJMS.demeter;import java.util.ArrayList;
import java.util.List;//客户端
public class Demeter2 {public static void main(String[] args) {
//创建了一个 SchoolManager 对象SchoolManager schoolManager = new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息schoolManager.printAllEmployee(new CollegeManager());}
}//学校总部员工类
class Employee {private String id;public void setId(String id) {this.id = id;}public String getId() {return id;}
}//学院的员工类
class CollegeEmployee {private String id;public void setId(String id) {this.id = id;}public String getId() {return id;}
}//管理学院员工的管理类
class CollegeManager {//返回学院的所有员工public List<CollegeEmployee> getAllEmployee() {List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();for (int i = 0; i < 10; i++) { //这里我们增加了 10 个员工到 listCollegeEmployee emp = new CollegeEmployee();emp.setId("学院员工 id= " + i);list.add(emp);}return list;}public void printEmployee() {
//问题解决
//1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
//3. 违反了 迪米特法则
//获取到学院员工List<CollegeEmployee> list1 = this.getAllEmployee();System.out.println("------------学院员工------------");for (CollegeEmployee e : list1) {System.out.println(e.getId());}}
}//学校管理类
//分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则
class SchoolManager {//返回学校总部的员工public List<Employee> getAllEmployee() {List<Employee> list = new ArrayList<Employee>();for (int i = 0; i < 5; i++) { //这里我们增加了 5 个员工到 listEmployee emp = new Employee();emp.setId("学校总部员工 id= " + i);list.add(emp);}return list;}//该方法完成输出学校总部和学院员工信息(id)void printAllEmployee(CollegeManager sub) {
//获取到学院员工sub.printEmployee();
//获取到学校总部员工List<Employee> list2 = this.getAllEmployee();System.out.println("------------学校总部员工------------");for (Employee e : list2) {System.out.println(e.getId());}}
}输出
------------学院员工------------
学院员工 id= 0
学院员工 id= 1
学院员工 id= 2
学院员工 id= 3
学院员工 id= 4
学院员工 id= 5
学院员工 id= 6
学院员工 id= 7
学院员工 id= 8
学院员工 id= 9
------------学校总部员工------------
学校总部员工 id= 0
学校总部员工 id= 1
学校总部员工 id= 2
学校总部员工 id= 3
学校总部员工 id= 4

七、合成复用原则 🚑

总结 ： 设计原则核心思想 🔞