您现在的位置是：首页 >技术教程 >第二章 设计模式七大原则网站首页技术教程

第二章 设计模式七大原则

无奈朝来寒雨晚来风 2023-05-27 20:00:02
简介第二章 设计模式七大原则

文章目录

前言

在这里插入图片描述
在这里插入图片描述

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

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 {

    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
}


class D implements Interface1, Interface3 {
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }

    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }

    @Override
    public 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 stub
        ChangHong 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 {
    @Override
    public void play() {
// TODO Auto-generated method stub
        System.out.println("长虹电视机，打开");
    }
}

在这里插入图片描述

四、里氏替换原则 🍇

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

package shejimoshi;

public class Liskov {
    public static void main(String[] args) {
// TODO Auto-generated method stub
        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();
        //这里本意是求出 11-3, 但由于子类不经意间重写了父类的方法，从而产生了不可预知的错误
        System.out.println("11-3=" + b.func1(11, 3));
        
        System.out.println("1-8=" + b.func1(1, 8));// 1-8
        System.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 stub
        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));


        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;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.out.println(" 绘制矩形 ");
    }
}
class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.out.println(" 绘制圆形 ");
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.out.println(" 绘制三角形 ");
    }
}
//新增一个图形
class OtherGraphic extends Shape {
    OtherGraphic() {
        super.m_type = 4;
    }
    @Override
    public void draw() {
// TODO Auto-generated method stub
        System.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 个员工到 list
            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<Employee>();
        for (int i = 0; i < 5; i++) { //这里我们增加了 5 个员工到 list
            Employee 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 个员工到 list
            CollegeEmployee 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 个员工到 list
            Employee 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

七、合成复用原则 🚑

在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐