• 设计模式——七大设计原则

    设计模式的目的

    设计模式体现了代码的耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性。

    • 代码重用性（形同功能的代码，不用多次编写）
    • 可读性（编程规范性，便于其他程序员的阅读和理解）
    • 可扩展性（当需要增加新的功能时，非常的方便）
    • 可靠性（当我们增加新的功能后，对原来的功能没有影响）
    • 使程序呈现高内聚，低耦合的特性

    一、单一职责原则（Single Responsibility）

    即一个类应该只负责一项职责。

    1. package com.taoke.designPattern.principle;
    2.  
    3. /**
    4.  * 单一职责原则
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class SingleResponsibility {
    10.  
    11.     public static void main(String[] args) {
    12.         Vehicle vehicle = new Vehicle();
    13.         vehicle.run("飞机");
    14.         vehicle.run("摩托车");
    15.         vehicle.run("汽车");
    16.     }
    17.  
    18. }
    19.  
    20. /**
    21.  * 交通工具中的run方法中违反 单一职责原则
    22.  * 应该将交通方式的不同，分解成不同的类
    23.  *
    24.  * @author taoke
    25.  * @date 2022/7/29
    26.  */
    27. class Vehicle {
    28.     public void run(String string) {
    29.         System.out.println(string + "在公路上运行。。。");
    30.     }
    31. }

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

    • 降低类的复杂度，一个类只负责一项职责
    • 提高类的可读性，可维护性
    • 降低变更引起的风险
    • 通常情况下，应当遵守单一职责原则， 只有逻辑足够简单，才可以在方法级违反单一职责原则

    二、接口隔离原则（Interface Segregation）

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

          类A通过Interface会依赖类B，但是类A只会使用到接口的1，2，3方法；类C通过Interface会依赖类B，但是类C只会使用到接口的4，5方法；那么接口Interface对于类A和类C来说不是最小接口

          根据接口隔离原则，应该将接口Interface拆分为多个接口，类A和类C应该与他们需要的接口产生联系

    1. package com.taoke.designPattern.principle;
    2.  
    3. /**
    4.  * 接口隔离原则
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class InterfaceSegregation {
    10.  
    11.     interface Interface1 {
    12.         void operate1();
    13.         void operate2();
    14.         void operate3();
    15.     }
    16.  
    17.     interface Interface2 {
    18.         void operate4();
    19.         void operate5();
    20.     }
    21.  
    22.     class A implements Interface1 {
    23.         @Override
    24.         public void operate1() {}
    25.  
    26.         @Override
    27.         public void operate2() {}
    28.  
    29.         @Override
    30.         public void operate3() {}
    31.     }
    32.  
    33.     class C implements Interface2 {
    34.  
    35.         @Override
    36.         public void operate4() {}
    37.  
    38.         @Override
    39.         public void operate5() {}
    40.     }
    41.  
    42.     class B implements Interface1, Interface2 {
    43.  
    44.         @Override
    45.         public void operate1() {}
    46.  
    47.         @Override
    48.         public void operate2() {}
    49.  
    50.         @Override
    51.         public void operate3() {}
    52.  
    53.         @Override
    54.         public void operate4() {}
    55.  
    56.         @Override
    57.         public void operate5() {}
    58.     }
    59. }

    三、依赖倒转原则（Dependence Inversion）

    • 高层模块不应该依赖低层模块，二者都应该依赖其抽象（缓冲层）

    • 抽象不应该依赖细节，细节应该依赖抽象

    • 依赖倒转(倒置)的中心思想是面向接口编程

    • 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中， 抽象指的是接口或抽象类，细节就是具体的实现类

    • 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

    依赖关系三种传递方式

    • 接口传递（依赖）
    • 构造方法传递（依赖）
    • setter方式传递（聚合）
    1. package com.taoke.designPattern.principle;
    2.  
    3. /**
    4.  * 依赖倒转原则
    5.  * 实现Person接收不同类型消息的功能，引入一个抽象的接口IReceive,表示接收者
    6.  * 这样Person类与接口IReceive发生依赖
    7.  *
    8.  * @author taoke
    9.  * @date 2022/7/29
    10.  */
    11. public class DependenceInversion {
    12.  
    13.     public static void main(String[] args) {
    14.         Person person = new Person();
    15.         person.receive(new Email());
    16.         person.receive(new Wechat());
    17.     }
    18. }
    19.  
    20. interface IReceive {
    21.     String getInfo();
    22. }
    23.  
    24. class Person {
    25.     public void receive(IReceive receive) {
    26.         System.out.println(receive.getInfo());
    27.     }
    28. }
    29.  
    30. class Email implements IReceive {
    31.  
    32.     @Override
    33.     public String getInfo() {
    34.         return "电子邮件信息";
    35.     }
    36. }
    37.  
    38. class Wechat implements IReceive {
    39.  
    40.     @Override
    41.     public String getInfo() {
    42.         return "微信信息";
    43.     }
    44. }

    四、里氏替换原则（Liskov Substitution）

    • 里氏替换原则(Liskov Substitution Principle)在1988年，由麻省理工学院一位姓里的女士提出

    • 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象

    • 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法

    • 继承实际上让两个类耦合性增强了，给程序带来侵入性。在适当的情况下，可以通过聚合，组合，依赖来解决问题

    • 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏

    1. package com.taoke.designPattern.principle;
    2.  
    3. /**
    4.  * 里氏替换原则
    5.  * A类没有重写父类的方法，B类重写了父类的方法
    6.  * A类继承父类，使用父类的方法，B类继承父类，并重写了父类的方法，造成错误
    7.  *
    8.  * @author taoke
    9.  * @date 2022/7/29
    10.  */
    11. public class LiskovSubstitution {
    12.     public static void main(String[] args) {
    13.         A a = new A();
    14.         System.out.println("2-1=" + a.func1(2, 1));
    15.  
    16.         B b = new B();
    17.         System.out.println("2-1=" + b.func1(2, 1));
    18.     }
    19. }
    20.  
    21. class Base {
    22.     /**
    23.      * 父类定义了一个基础方法
    24.      *
    25.      * @param num1 数值1
    26.      * @param num2 数值2
    27.      * @return 值
    28.      */
    29.     public int func1(int num1, int num2) {
    30.         return num1 - num2;
    31.     }
    32. }
    33.  
    34. class A extends Base {
    35. }
    36.  
    37. class B extends Base {
    38.     /**
    39.      * 重写了父类方法，造成原有方法发生改变。
    40.      *
    41.      * @param num1 数值1
    42.      * @param num2 数值2
    43.      * @return 值
    44.      */
    45.     @Override
    46.     public int func1(int num1, int num2) {
    47.         return num1 + num2;
    48.     }
    49. }

    五、开闭原则 OCP（Open Closed）

    • 开闭原则(Open Closed Principle) 是编程中最基础、最重要的设计原则
    • 一个软件实体，比如类，模块和函数应该对提供方扩展开放，对使用方修改关闭。用抽象构建框架，用实现扩展细节
    • 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
    • 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则
    1. package com.taoke.designPattern.principle;
    2.  
    3. /**
    4.  * 开闭原则
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class OpenClosed {
    10.     public static void main(String[] args) {
    11.         Use use = new Use();
    12.         use.drawShape(new Triangle());
    13.         use.drawShape(new Circle());
    14.         //只需要让 此类继承 抽象类，子类实现具体方法  OCP原则
    15.         use.drawShape(new OtherGraphics());
    16.     }
    17. }
    18.  
    19. class Use {
    20.     public void drawShape(Shape shape) {
    21.         shape.draw();
    22.     }
    23. }
    24.  
    25. abstract class Shape {
    26.     public abstract void draw();
    27. }
    28.  
    29. class Triangle extends Shape {
    30.  
    31.     @Override
    32.     public void draw() {
    33.         System.out.println("子类实现具体功能：三角形");
    34.     }
    35. }
    36.  
    37. class Circle extends Shape {
    38.  
    39.     @Override
    40.     public void draw() {
    41.         System.out.println("子类实现具体功能：圆形");
    42.     }
    43. }
    44.  
    45. class OtherGraphics extends Shape {
    46.  
    47.     @Override
    48.     public void draw() {
    49.         System.out.println("子类实现具体功能：任何形状");
    50.     }
    51. }

    六、迪米特法则（Demeter）

    • 一个对象应该对其他对象保持最少的了解
    • 类与类关系越密切，耦合度越大。
    • 迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供public方法，不对外泄露任何信息
    • 迪米特法则更简单的定义：只与直接的朋友通信
    • 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合 等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部

    直接的朋友

    1. class A{
    2. 	B b;//全局变量 - 直接朋友
    3. 	public B m1(){} //方法返回值 - 直接朋友
    4. 	public void m2(B b){}//方法入参 - 直接朋友
    5. 	public void m3(){
    6. 		B b1 = new B();// 局部变量 非直接朋友
    7. 	}
    8. }

    1. package com.taoke.principle;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. /**
    7.  * 迪米特法则
    8.  * 学校管理类应该最少知道学院员工的信息
    9.  * printAllEmployee 方法中，只提供方法，不把具体实现放在其他类里面。
    10.  *
    11.  * @author taoke
    12.  * @date 2022/7/29
    13.  */
    14. public class Demeter {
    15.     public static void main(String[] args) {
    16.         SchoolManager schoolManager = new SchoolManager();
    17.         schoolManager.printAllEmployee(new CollegeManager());
    18.     }
    19. }
    20.  
    21. /**
    22.  * 学院员工类
    23.  */
    24. class CollegeEmployee {
    25.     private String id;
    26.  
    27.     public String getId() {
    28.         return id;
    29.     }
    30.  
    31.     public void setId(String id) {
    32.         this.id = id;
    33.     }
    34. }
    35.  
    36. /**
    37.  * 管理学院员工的管理类
    38.  */
    39. class CollegeManager {
    40.     //返回学院的所有员工
    41.     public List getAllEmployee() {
    42.         List list = new ArrayList<>();
    43.         //这里我们增加了10 个员工到list ，
    44.         for (int i = 0; i < 10; i++) {
    45.             CollegeEmployee emp = new CollegeEmployee();
    46.             emp.setId("学院员工id " + i);
    47.             list.add(emp);
    48.         }
    49.         return list;
    50.     }
    51.  
    52.     /**
    53.      * 打印学院所有的员工
    54.      */
    55.     public void printCollegeEmployee() {
    56.         List list = this.getAllEmployee();
    57.         System.out.println("---学院员工----");
    58.         for (CollegeEmployee e : list) {
    59.             System.out.println(e.getId());
    60.         }
    61.     }
    62. }
    63.  
    64. /**
    65.  * 学校员工类
    66.  */
    67. class SchoolEmployee {
    68.  
    69.     private String id;
    70.  
    71.     public String getId() {
    72.         return id;
    73.     }
    74.  
    75.     public void setId(String id) {
    76.         this.id = id;
    77.     }
    78. }
    79.  
    80. /**
    81.  * 学校管理类
    82.  */
    83. class SchoolManager {
    84.     //返回学校总部的员工
    85.     public List getAllEmployee() {
    86.         List list = new ArrayList<>();
    87.         //这里我们增加了5个员工到list
    88.         for (int i = 0; i < 5; i++) {
    89.             SchoolEmployee emp = new SchoolEmployee();
    90.             emp.setId("学校总部员工id= " + i);
    91.             list.add(emp);
    92.         }
    93.         return list;
    94.     }
    95.  
    96.     /**
    97.      * 该方法完成输出学校总部和学院员工信息(id)
    98.      *
    99.      * @param collegeManager 管理学院员工的管理类
    100.      */
    101.     void printAllEmployee(CollegeManager collegeManager) {
    102.         //只提供方法，不把具体实现放在其他类里面。
    103.         collegeManager.printCollegeEmployee();
    104.         //获取到学校总部员工
    105.         List list = this.getAllEmployee();
    106.         System.out.println("------学校总部员工------");
    107.         for (SchoolEmployee e : list) {
    108.             System.out.println(e.getId());
    109.         }
    110.     }
    111. }

    七、合成复用原则（Composite Reuse）

    合成复用原则 尽量使用组合/聚合的方式，而不是使用继承。

    1. package com.taoke.principle;
    2.  
    3. /**
    4.  * 合成复用原则
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class CompositeReuse {
    10.     public static void main(String[] args) {
    11.         System.out.println("------依赖------");
    12.         B b = new B();
    13.         b.Operation1(new A());
    14.  
    15.         System.out.println("------聚合------");
    16.         b.setA(new A());
    17.         b.Operation2();
    18.  
    19.         System.out.println("------组合------");
    20.         b.Operation3();
    21.     }
    22.  
    23.     static class A {
    24.         void Operation1() {
    25.             System.out.println("A Operation1");
    26.         }
    27.  
    28.         void Operation2() {
    29.             System.out.println("A Operation2");
    30.         }
    31.  
    32.         void Operation3() {
    33.             System.out.println("A Operation3");
    34.         }
    35.     }
    36.  
    37.     /**
    38.      * 如果只是需要用到 A类的方法，尽量不要使用继承。而是使用，依赖，聚合，组合的方式
    39.      */
    40.     static class B {
    41.         /**
    42.          * 依赖
    43.          *
    44.          * @param a 实例a
    45.          */
    46.         void Operation1(A a) {
    47.             a.Operation1();
    48.             a.Operation2();
    49.             a.Operation3();
    50.         }
    51.  
    52.         //==============================================================
    53.         A a;
    54.  
    55.         public void setA(A a) {
    56.             this.a = a;
    57.         }
    58.  
    59.         /**
    60.          * 聚合
    61.          */
    62.         void Operation2() {
    63.             a.Operation1();
    64.             a.Operation2();
    65.             a.Operation3();
    66.         }
    67.  
    68.         //==============================================================
    69.         A a1 = new A();
    70.  
    71.         /**
    72.          * 组合
    73.          */
    74.         void Operation3() {
    75.             a1.Operation1();
    76.             a1.Operation2();
    77.             a1.Operation3();
    78.         }
    79.     }
    80. }

    类与类之间的关系

    依赖（Dependence）

    只要是在类中用到了对方，那么他们之间就存在依赖关系。

    • 类的成员属性；
    • 方法的返回类型；
    • 方法接收的参数类型；
    • 方法中使用到。
    1. package com.taoke.relation;
    2.  
    3. /**
    4.  * 依赖关系
    5.  * 1、类中用到了对方
    6.  * 2、类的成员属性
    7.  * 3、方法的返回类型
    8.  * 4、方法接收的参数类型
    9.  * 5、方法中使用到
    10.  *
    11.  * @author taoke
    12.  * @date 2022/7/29
    13.  */
    14. public class Dependence {
    15.     /**
    16.      * 类的成员属性
    17.      */
    18.     A a;
    19.  
    20.     public A save(B b) {//方法接收的参数类型
    21.         System.out.println();
    22.         //方法中使用到
    23.         A a = new A();
    24.         //方法的返回类型
    25.         return a;
    26.     }
    27. }
    28.  
    29. class A {
    30. }
    31.  
    32. class B {
    33. }

    继承（泛化 Generalization）

    泛化关系实际上就是继承关系，依赖关系的特例

    1. package com.taoke.relation;
    2.  
    3. /**
    4.  * 继承
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class Generalization extends Base {
    10.  
    11.     @Override
    12.     public void get(Object oId) {
    13.  
    14.     }
    15.  
    16.     @Override
    17.     public void put(Object oName) {
    18.  
    19.     }
    20. }
    21.  
    22. abstract class Base {
    23.     abstract public void get(Object oId);
    24.  
    25.     abstract public void put(Object oName);
    26. }

    实现（Realization）

    实现关系实际上就是 A类 实现 B接口，依赖关系的特例。

    1. package com.taoke.relation;
    2.  
    3. /**
    4.  * 实现
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class Implementation implements Interface {
    10.     @Override
    11.     public void init() {
    12.         System.out.println("init");
    13.     }
    14. }
    15.  
    16. interface Interface {
    17.     void init();
    18. }

    关联（Association）

    类与类之间的关系，依赖关系的特例。关联具有导航性，即双向关系或单向关系。

    1. package com.taoke.relation;
    2.  
    3. /**
    4.  * 关联
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class Association {
    10.     class Person {
    11.         private IDCard idCard;
    12.     }
    13.  
    14.     class IDCard {
    15.         private Person person;
    16.     }
    17. }
    18.

    聚合（Aggregation）

    表示的是整体和部分的关系，整体与部分可以分开，关联关系的特例；聚合关系是关联关系的特例，所以他具有关联的导航性与多重性。

    1. package com.taoke.relation;
    2.  
    3. /**
    4.  * 聚合
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class Aggregation {
    10.  
    11.     class Computer {
    12.         private Mouse mouse;
    13.         private Keyboard keyboard;
    14.  
    15.         public void setMouse(Mouse mouse) {
    16.             this.mouse = mouse;
    17.         }
    18.  
    19.         public void setKeyboard(Keyboard keyboard) {
    20.             this.keyboard = keyboard;
    21.         }
    22.     }
    23.  
    24.     class Mouse {
    25.     }
    26.  
    27.     class Keyboard {
    28.     }
    29. }
    30.  
    31.

    组合（Composite）

    整体与部分的关系，但是整体与部分不可以分开，关联关系的特例。级联删除就是组合关系。

    1. package com.taoke.relation;
    2.  
    3. /**
    4.  * 组合
    5.  *
    6.  * @author taoke
    7.  * @date 2022/7/29
    8.  */
    9. public class Composite {
    10.  
    11.     public class Computer {
    12.         private CPU cpu = new CPU();
    13.         private SSD ssd = new SSD();
    14.     }
    15.  
    16.     static class CPU {
    17.     }
    18.  
    19.     static class SSD {
    20.     }
    21. }

  • 相关阅读:
    Lambda总结
    CTFHub技能树 Web-SQL注入详解
    【PACS系统源码】与医院HIS系统双向数据交换，实现医学影像集成与影像后处理功能
    rabbitmq 交换机相关实例代码
    NLog配置文件详解
    简明SQL截断和偏移指南：掌握 LIMIT 和 OFFSET 实现数据筛选
    odoo关于计算字段store=True时导致的安装/更新时间较长问题的解决方案
    计算机组成原理-输入输出系统(持续更新中)
    C语言数组清零----使用memset函数
    深入浅出计算机组成原理04-穿越功耗墙，我们该从哪些方面提升“性能”？
  • 原文地址：https://blog.csdn.net/Strange_boy/article/details/126049326