Java设计模式遵循的七大原则

小鱼儿 2023-10-12 08:34 93阅读 0赞

**设计模式遵循七大原则有：**  
  
**单一职责原则  
接口隔离原则  
开闭原则  
依赖倒转(倒置)原则  
里氏替换原则  
迪米特法则  
合成复用原则**

## 1. 单一职责原则 ##

### 1.1 基本介绍 ###

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

### 1.2 案例 ###

可以看到Vehicle这个类承担了它这个年纪不该承担的压力，火车、飞机与轮船通过一个方法共同输出导致出现不符合实际的结果

public class sigleResponsibility {
        
        public static void main(String[] args) {
        
            Vehicle vehicle = new Vehicle();
            vehicle.run("火车");
            vehicle.run("飞机");
            vehicle.run("轮船");
        }
    }

class Vehicle {
        
        public void run(String vehicle) {
        
            System.out.println(vehicle+"在公路上运行");
        }
    }

例子改进  
这里我们写出了另外两个方法，实现了方法级别的单一职责，但是当我们需要对各种类别添加其他方法（比如对空中的交通工具加其他方法）时我们就需要继续改进

public class sigleResponsibility {
        
        public static void main(String[] args) {
        
            Vehicle vehicle = new Vehicle();
            vehicle.run("火车");
            vehicle.runair("飞机");
            vehicle.runwater("轮船");
        }
    }

class Vehicle {
        
        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+"在水上上运行");
        }
    }

例子再改进

到这一步，我们就已经遵从了类上的单一职责原则，可能看起来会觉得第二种更加简短与实用，但是这些原则都是为了给巨大的项目打地基用的，而不是为了单单着眼于实现一个功能。

public class sigleResponsibility {
        
        public static void main(String[] args) {
        
            Vehicle vehicle1 = new Vehicle();
            vehicle1.run("火车");
            AirVehicle vehicle2 = new AirVehicle();
            vehicle2.run("飞机");
            WaterVehicle vehicle3 = new WaterVehicle();
            vehicle3.run("轮船");
        }
    }

class Vehicle {
        
        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+"在水上上运行");
        }
    }

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

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

## 2. 接口隔离原则 ##

接口隔离原则(Interface Segregation Principle)

### 2.1 基本介绍 ###

1.  客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

类A通过接口interface1依赖类B，类c通过接口interface1依赖类D，如果接口Interface1对于类A和类c来说不是最小接口那么类B和类D必须去实现他们不需要的方去。  
按隔离原则应当这样处理:将接口interface1折分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

### 2.2 案例 ###

interface Interface1 {
        
        void op1();
        void op2();
        void op3();
        void op4();
        void op5();
    }

class B implements Interface1 {
        
        public void op1() {
        
            System.out.println("B 实现了 op1");
        }
        public void op2() {
        
            System.out.println("B 实现了 op21");
        }
        public void op3() {
        
            System.out.println("B 实现了 op3");
        }
        public void op4() {
        
            System.out.println("B 实现了 op4");
        }
        public void op5() {
        
            System.out.println("B 实现了 op5");
        }
    }

class D implements Interface1 {
        
        public void op1() {
        
            System.out.println("D 实现了 op1");
        }
        public void op2() {
        
            System.out.println("D 实现了 op21");
        }
        public void op3() {
        
            System.out.println("D 实现了 op3");
        }
        public void op4() {
        
            System.out.println("D 实现了 op4");
        }
        public void op5() {
        
            System.out.println("D 实现了 op5");
        }
    }

class A {
        
        public void op1(Interface1 i) {
        
            i.op1();
        }
        public void op2(Interface1 i) {
        
            i.op2();
        }
        public void op3(Interface1 i) {
        
            i.op3();
        }
    }

class C {
        
        public void op1(Interface1 i) {
        
            i.op1();
        }
        public void op4(Interface1 i) {
        
            i.op4();
        }
        public void op5(Interface1 i) {
        
            i.op5();
        }
    }

应传统方法的问题和使用接口隔离原则改进  
问题：类A通过接口Interface1依赖类B，类c通过接口Interface1依赖类D，如果接口interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法  
解决方案：将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则接口interface1中出现的方法，根据实际情况拆分为三个接口代码实现

例子改进

//接口1

interface Interface1 {
        
        void op1();
    }

//接口2

interface Interface2 {
        
        void op2();
        void op3();
    }

//接口3

interface Interface3 {
        
        void op4();
        void op5();
    }

class B implements Interface1,Interface2 {
        
        public void op1() {
        
            System.out.println("B 实现了 op1");
        }
        public void op2() {
        
            System.out.println("B 实现了 op2");
        }
        public void op3() {
        
            System.out.println("B 实现了 op3");
        }
    }

class D implements Interface1,Interface3 {
        
        public void op1() {
        
            System.out.println("D 实现了 op1");
        }
        public void op4() {
        
            System.out.println("D 实现了 op4");
        }
        public void op5() {
        
            System.out.println("D 实现了 op5");
        }
    }

class A {
        
        public void op1(Interface1 i) {
        
            i.op1();
        }
        public void op2(Interface2 i) {
        
            i.op2();
        }
        public void op3(Interface2 i) {
        
            i.op3();
        }
    }

class C {
        
        public void op1(Interface1 i) {
        
            i.op1();
        }
        public void op4(Interface3 i) {
        
            i.op4();
        }
        public void op5(Interface3 i) {
        
            i.op5();
        }
    }

调用

public class segragation {
        
        public static void main(String[] args) {
        
            A a = new A();
            a.dependcy1(new B());
            a.dependcy2(new B());
            a.dependcy3(new B());
            C c = new C();
            c.dependcy1(new D());
            c.dependcy4(new D());
            c.dependcy5(new D());
        }
    }

也可以通过模板模式解决！

## 3. 开闭原则 ##

### 3.1. 开闭原则基本介绍 ###

1.  开闭原则（Open Closed Principle），又称OCP原则，是编程中最基础、最重要的设计原则
2.  一个实体类、模块和函数应该对**扩展开放**（对提供方），对**修改关闭**（对使用方）。用抽象构建框架，用实现扩展细节。
3.  当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
4.  编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则。

### 3.2 案例 ###

需求  
购买东西的时候，根据支付类型的不同使用不同的方式进行支付，当支付类型为1时，使用微信支付；当支付类型为2时，使用支付宝支付。

测试类

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

用于绘图的类\[使用方\]

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 r) {
        
            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;
        }
    }

运行结果  
![在这里插入图片描述][0fbbbea4aba44344bcff7544993ee651.png]

以上代码的优缺点

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

测试类

//用于绘图的类\[使用方\]

class GraphicEditor {
        
        //接收不同的对象并调用相应的方法
        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)
                drawRectangle(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("绘制三角形");
        }
    }

基类

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;
        }
    }

例子改进  
测试类

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

//用于绘图的类

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("绘制三角形");
        }
    }

分析  
对于提供方直接新增类即可，使用方无需新增方法

## 4. 依赖倒转原则 ##

### 4.1 基本介绍 ###

1.  依赖倒转原则(Dependence Inversion Principle)是指:高层模块不应该依赖低层模块，二者都应该依赖其抽象
2.  抽象不应该依赖细节，细节应该依赖抽象
3.  依赖倒转(倒置)的中心思想是面向接口编程
4.  依赖倒转原则是基于这样的设计理念: 相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类
5.  使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

### 4.2 案例 ###

完成person接收消息

public class DependencyInvertion {
        
        public static void main(String[] args) {
        
            Person person = new Person();
            person.receive(new Email());
        }
    }

class Email {
        
        public String getInfo() {
        
            return "电子邮件信息：hello";
        }
    }

完成person接收消息的功能

class Person {
        
        public void receive(Email email) {
        
            System.out.println(email.getInfo());
        }
    }

运行结果  
![在这里插入图片描述][a52a0380894f4939b51b653c7888e26a.png]

**分析**  
问题：虽然比较容易想到且实现起来很简单，但是当我们接收消息的类不是email，而是message或者WeChat的时候，我们就需要新建类，且Person类需要新增方法，因为它的方法的参数已经定义为Email类

**解决思路**

引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖因为Email，Weixin 等等属于接收的范围，他们各自实现IReceiver 接口就ok，这样我们就符合依赖倒转原则

### 4.3 案例改进 ###

可以看到依赖抽象（接口或者抽象类）的稳定性相比于依赖细节（具体实现）更高，不需要增加方法，只需要增加类即可

public class DependencyInvertion {
        
        public static void main(String[] args) {
        
            //客户端无需改变
            Person person = new Person();
            person.receive(new Email());
            person.receive(new WeChat());
        }
    }

interface IReceive {
        
        public String getInfo();
    }

class Email implements IReceive{
        
        public String getInfo() {
        
            return "电子邮件信息：hello，Email";
        }
    }

class WeChat implements IReceive {
        
        @Override
        public String getInfo() {
        
            return "微信信息：hello，Wechat";
        }
    }

完成person接收消息的功能

class Person {
        
        public void receive(IReceive receive) {
        
            System.out.println(receive.getInfo());
        }
    }

依赖关系传递的三种方式和应用案例

### 4.4 接口传递 ###

// 方式 1: 通过接口传递实现依赖
    // 开关的接口
    interface IOpenAndClose {
        
        public void open(ITV tv);//抽象方法，接收接口
    }
    
    interface ITV {
         //ITV接口
        public void play();
    }
    
    class ChangHong implements ITV {
        
        @Override
        public void play() {
        
            System.out.println("长虹电视机开启");
        }
    }
    
    //实现接口
    class OpenAndClose implements IOpenAndClose{
        
        public void open(ITV tv){
        
            tv.play();
        }
    }

### 4.5 构造方法传递 ###

public class DependencyInvertion {
        
        public static void main(String[] args) {
        
            ChangHong changHong = new ChangHong();
            OpenAndClose openAndClose = new OpenAndClose(changHong);
            openAndClose.open();
        }
    }
    
    // 方式2: 通过构造方法依赖传递
    interface IOpenAndClose {
        
        public void open();
    }
    
    
    //抽象方法
    
    interface ITV {
        //ITV接口
        public void play();
    }
    
    class ChangHong implements ITV {
        
        @Override
        public void play() {
        
            System.out.println("长虹电视机开启");
        }
    }
    
    class OpenAndClose implements IOpenAndClose{
        
        public ITV tv; //成员
        public OpenAndClose(ITV tv) {
         //构造器
            this.tv = tv;
        }
     
        public void open(){
        
            this.tv.play();
        }
    }

### 4.6 setter方式传递 ###

public class DependencyInvertion {
        
        public static void main(String[] args) {
        
            ChangHong changHong = new ChangHong();
            OpenAndClose openAndClose = new OpenAndClose();
            openAndClose.setTv(changHong);
            openAndClose.open();
        }
    }
    
     //方式3，通过setter方法传递
    interface IOpenAndClose {
        
        public void open(); // 抽象方法
        public void setTv(ITV tv);
    }
    
    interface ITV {
         // ITV接口
        public void play();
    }
    
    class ChangHong implements ITV {
        
        @Override
        public void play() {
        
            System.out.println("长虹电视机开启");
        }
    }
    
    class OpenAndClose implements IOpenAndClose {
        
        private ITV tv;
        public void setTv(ITV tv) {
        
            this.tv = tv;
        }
        public void open() {
        
            this.tv.play();
        }
    }

运行结果

![在这里插入图片描述][1e482d96ad5143738b42e3fd7944b97a.png]

**依赖倒转原则的注意事项和细节**  
1. 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好  
2. 变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化  
3. 继承时遵循里氏替换原则

## 5.里氏替换原则 ##

**OO 中的继承性的思考和说明**

1.  继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。
2.  继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障
3.  问题提出：在编程中，如何正确的使用继承? => **里氏替换原则**

### 5.1 基本介绍 ###

1.  里氏替换原则(**Liskov Substitution Principle**)在1988年，由麻省理工学院的以为姓里的女士提出的。
2.  如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象。
3.  在使用继承时，遵循里氏替换原则，在子类中**尽量**不要重写父类的方法
4.  里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，**在适当的情况下，可以通过聚合，组合，依赖 来解决问题。**

### 5.2 案例 ###

B在无意的情况下重写了A类的func1方法，使得调用的时候使用的是自己所写的方法，破坏了原来的功能。

public class Liskov {
        
        public static void main(String[] args) {
        
            A 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-3，即调用父类的方法
            System.out.println("1-8=" + b.func1(1, 8));// 同上，求1-8
            System.out.println("11+3+9=" + b.func2(11, 3));
        }
    }
     
    class A {
        
        //返回两个数的差
        public int func1 (int num1, int num2) {
        
            return num1 - num2;
        }
    }
     
    class B extends A {
        
        //返回两个数的差，无意的重写了父类的方法
        public int func1(int a, int b) {
        
            return a + b;
        }
        public int func2(int a, int b) {
        
            return func1(a, b) + 9;
        }
    }

运行结果  
![在这里插入图片描述][16ad7f0b82f4463da42e4bd04e97d818.png]

分析

**解决方法**

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

public class Liskov {
        
        public static void main(String[] args) {
        
            A 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();
            //因此此时B不再继承A类，所以不会再认为func1是求减法的
            //调用完成的功能会很明确
            System.out.println("11+3=" + b.func1(11, 3));
            System.out.println("1+8=" + b.func1(1, 8));
            System.out.println("11+3+9=" + b.func2(11, 3));
            //使用组合仍然可以使用A类相关方法
            System.out.println("11-3="+b.func3(11,3));
        }
    }
    
    //基类
    class Base {
        
        //把更加基础的方法和成员写到Base类
    }
    
    class A extends Base{
        
        //返回两个数的差
        public int func1 (int num1, int num2) {
        
            return num1 - num2;
        }
    }
     
    class B extends Base {
        
        public A a = new A();
        //返回两个数的差，无意的重写了父类的方法
        public int func1(int a, int b) {
        
            return a + b;
        }
        public int func2(int a, int b) {
        
            return func1(a, b) + 9;
        }
        public int func3(int a, int b) {
         return this.a.func1(a, b);}
    }

运行结果

UML类图  
![在这里插入图片描述][2b1335342d634480936170b335b99398.png]

[0fbbbea4aba44344bcff7544993ee651.png]: https://img-blog.csdnimg.cn/0fbbbea4aba44344bcff7544993ee651.png
[a52a0380894f4939b51b653c7888e26a.png]: https://img-blog.csdnimg.cn/a52a0380894f4939b51b653c7888e26a.png
[1e482d96ad5143738b42e3fd7944b97a.png]: https://img-blog.csdnimg.cn/1e482d96ad5143738b42e3fd7944b97a.png
[16ad7f0b82f4463da42e4bd04e97d818.png]: https://img-blog.csdnimg.cn/16ad7f0b82f4463da42e4bd04e97d818.png
[2b1335342d634480936170b335b99398.png]: https://img-blog.csdnimg.cn/2b1335342d634480936170b335b99398.png