设计模式-七大原则

向右看齐 2023-05-22 22:36 76阅读 0赞

## 1.设计模式的目的 ##

设计模式是为了让程序(软件)， 具有更好

1.  代码重用性 (即： 相同功能的代码， 不用多次编写)
2.  可读性 (即： 编程规范性, 便于其他程序员的阅读和理解)
3.  可扩展性 (即： 当需要增加新的功能时， 非常的方便， 称为可维护)
4.  可靠性 (即： 当我们增加新的功能后， 对原来的功能没有影响)
5.  使程序呈现高内聚， 低耦合的特性

## 2.设计模式七大原则 ##

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

### 2.1 单一职责原则 ###

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

方案1–违反单一职责：

//违反单一职责案例1
    public class SingleResponsibility {
        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 + "在公路上运行...");
        }
    }
    // 1. 在方式 1 的 run 方法中， 违反了单一职责原则
    // 2. 解决的方案非常的简单， 根据交通工具运行方法不同， 分解成不同类即可

方案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("飞机");
        }
    }
    
    class RoadVehicle{
        public void run(String vehicle){
            System.out.println(vehicle + "在公路上运行...");
        }
    }
    
    class AirVehicle{
        public void run(String vehicle){
            System.out.println(vehicle + "在天空运行...");
        }
    }
    //1. 遵守单一职责原则
    //2. 但是这样做的改动很大， 即将类分解， 同时修改客户端
    //3. 改进： 直接修改 Vehicle 类， 改动的代码会比较少=>方案 3

方案3

//根据单一职责改进方案3
    public class SingleResponsibility3 {
        public static void main(String[] args) {
            Vehicle2 vehicle2 = new Vehicle2();
            vehicle2.run("汽车");
            vehicle2.runAir("飞机");
            vehicle2.runWater("轮船");
        }
    }
    
    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. 这种修改方法没有对原来的类做大的修改， 只是增加方法
    //2. 这里虽然没有在类这个级别上遵守单一职责原则， 但是在方法级别上， 仍然是遵守单一职责

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

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

### 2.2 接口隔离原则 ###

1.  客户端不应该依赖它不需要的接口， 即一个类对另一个类的依赖应该建立在最小的接口上
2.  类 A 通过接口 Interface1 依赖类 B， 类 C 通过接口 Interface1 依赖类 D， 如果接口 Interface1 对于类 A 和类 C来说不是最小接口， 那么类 B 和类 D 必须去实现他们不需要的方法。
3.  按隔离原则应当这样处理：  
    将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)， 类 A 和类 C 分别与他们需要的接口建立依赖关系。 也就是采用接口隔离原则

举例：  
类 A 通过接口 Interface1 依赖类 B，但是只会用到接口中的1，2，3 三个方法；类 C 通过接口 Interface1 依赖类 D，但是会用到接口中的1，4，5三个方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70]  
违反接口隔离原则：

public class Segregation1 {
        public static void main(String[] args) {
    
        }
    }
    
    interface Interface1 {
        void operation1();
    
        void operation2();
    
        void operation3();
    
        void operation4();
    
        void operation5();
    }
    class B implements Interface1 {
        public void operation1() {
            System.out.println("B 实现了 operation1");
        }
    
        public void operation2() {
            System.out.println("B 实现了 operation2");
        }
    
        public void operation3() {
            System.out.println("B 实现了 operation3");
        }
    
        public void operation4() {
            System.out.println("B 实现了 operation4");
        }
    
        public void operation5() {
            System.out.println("B 实现了 operation5");
        }
    }
    class D implements Interface1 {
        @Override
        public void operation1() {
            System.out.println("D 实现了 operation1");
        }
    
        @Override
        public void operation2() {
            System.out.println("D 实现了 operation2");
        }
    
        @Override
        public void operation3() {
            System.out.println("D 实现了 operation3");
        }
    
        @Override
        public void operation4() {
            System.out.println("D 实现了 operation4");
        }
    
        @Override
        public void operation5() {
            System.out.println("D 实现了 operation5");
        }
    }
    class A { //A 类通过接口 Interface1 依赖(使用) B 类， 但是只会用到 1,2,3 方法
        public void depend1(Interface1 i) {
            i.operation1();
        }
    
        public void depend2(Interface1 i) {
            i.operation2();
        }
    
        public void depend3(Interface1 i) {
            i.operation3();
        }
    }
    class C { //C 类通过接口 Interface1 依赖(使用) D 类， 但是只会用到 1,4,5 方法
        public void depend1(Interface1 i) {
            i.operation1();
        }
    
        public void depend4(Interface1 i) {
            i.operation4();
        }
    
        public void depend5(Interface1 i) {
            i.operation5();
        }
    }

根据接口隔离原则改进：

public class Segregation2 {
        public static void main(String[] args) {
            A a = new A();
            a.depend1(new B());
            a.depend2(new B());
            a.depend3(new B());
            C c = new C();
            c.depend1(new D());
            c.depend4(new D());
            c.depend5(new D());
        }
    }
    
    interface Interface1 {
        void operation1();
    }
    
    interface Interface2 {
        void operation2();
        void operation3();
    }
    
    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 {
        public void operation1() {
            System.out.println("D 实现了 operation1");
        }
    
        public void operation4() {
            System.out.println("D 实现了 operation4");
        }
    
        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();
        }
    }

### 2.3 依赖倒转原则 ###

依赖倒转原则(Dependence Inversion Principle)是指：

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

依赖传递的3种方式：

1.  接口传递
2.  构造方法传递
3.  setter 方式传递

举例：  
反例：

public class DependecyInversion {
        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());
        }
    }

根据依赖倒转原则改进–接口传递：

public class DependecyInversion2 {
        public static void main(String[] args) {
            Person person = new Person();
            person.receive(new Email());
            person.receive(new Weixin());
        }
    }
    
    interface IReciver{
        String getInfo();
    }
    
    class Email implements IReciver{
        public String getInfo(){
            return "电子邮件信息：Hello world";
        }
    }
    
    class Weixin implements IReciver{
        public String getInfo(){
            return "微信信息：Hello world";
        }
    }
    
    class Person{
        public void receive(IReciver iReciver){
            System.out.println(iReciver.getInfo());
        }
    }

根据依赖倒转原则改进–构造器传递：

//通过构造器实现
    public class DependecyInversion3 {
        public static void main(String[] args) {
           OpenAndClose openAndClose = new OpenAndClose(new ChangHong());
            openAndClose.open();
    
        }
    }
    
    interface IOpenAndClose{
        void open();
    }
    
    interface ITV{
        void play();
    }
    
    class OpenAndClose implements IOpenAndClose{
        public ITV itv;
    
        public OpenAndClose(ITV itv) {
            this.itv = itv;
        }
    
        @Override
        public void open() {
            itv.play();
        }
    }
    class ChangHong implements ITV{
        @Override
        public void play() {
            System.out.println("手动打开关闭...");
        }
    }
    class HaiXin implements ITV{
    
        @Override
        public void play() {
            System.out.println("自动打开关闭...");
        }
    }

根据依赖倒转原则改进–set方法传递：

public class DependecyInversion4 {
        public static void main(String[] args) {
            OpenAndClose openAndClose = new OpenAndClose();
            openAndClose.setTv(new HaiXin());
            openAndClose.open();
        }
    }
    interface IOpenAndClose{
        void open();
        void setTv(ITV tv);
    }
    
    interface ITV{
        void play();
    }
    
    class OpenAndClose implements IOpenAndClose{
        public ITV itv;
    
        public void setTv(ITV itv){
            this.itv = itv;
        }
    
        @Override
        public void open() {
            itv.play();
        }
    }
    class ChangHong implements ITV{
        @Override
        public void play() {
            System.out.println("手动打开关闭...");
        }
    }
    class HaiXin implements ITV{
    
        @Override
        public void play() {
            System.out.println("自动打开关闭...");
        }
    }

依赖倒转原则的注意事项和细节：

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

### 2.4 里氏替换原则 ###

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

违法原则代码示例：

public class Test {
        public static void main(String[] args) {
            B b = new B();
            int sum = b.sum(1, 2);
            System.out.println(sum);
        }
    }
    class A{
        public int sum(int a,int b){
            return a+b;
        }
    }
    class B extends A{
        public int sum(int a,int b){
            return a-b;
        }
    }

解决：

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

正确代码示例：

public class Test {
        public static void main(String[] args) {
            B b = new B();
            int sum = b.sum(1, 2);
            System.out.println(sum);
        }
    }
    //抽象出一个基类来存放A，B的共同要继承的方法
    class Base{
        public int basefun(int a,int b){
            return a-b;
        }
    }
    class A extends Base{
        public int sum(int a,int b){
            return a+b;
        }
    }
    class B extends Base{
        //B要调用A种的方法 采用组合方法
        private A a = new A();
        public int sum(int a,int b){
            return this.a.sum(a,b);
        }
    }

### 2.5 开闭原则（ocp） ###

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

违法规则代码

public class Ocp {
        public static void main(String[] args) {
    
            //使用者
            GraphicEditor graphicEditor = new GraphicEditor();
            graphicEditor.drawShap(new Rectangle());//调用绘制矩形
            graphicEditor.drawShap(new Circle());//调用绘制圆形
            graphicEditor.drawShap(new Triangle());//新增业务---调用绘制圆形
        }
    
    
    }
    
    //使用者
    class GraphicEditor{
        //接收 Shape 对象， 然后根据 type， 来绘制不同的图形
        public void drawShap(Shape s){
            if(s.m_type == 1){
                drawRectangle(s);
            }
            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;
        }
    }

以上代码的优缺点：

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

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

public class Ocp {
        public static void main(String[] args) {
    
            //使用者
            GraphicEditor graphicEditor = new GraphicEditor();
            graphicEditor.drawShap(new Rectangle());//调用绘制矩形
            graphicEditor.drawShap(new Circle());//调用绘制圆形
            graphicEditor.drawShap(new Triangle());//调用绘制三角形
            graphicEditor.drawShap(new OtherShape());//改进后的代码绘制其他图形
        }
    
    
    }
    
    //使用者
    class GraphicEditor{
        public void drawShap(Shape s){
            s.draw();
        }
    }
    
    //提供者
    abstract class Shape{
        public abstract void draw();
    }
    
    class Rectangle extends Shape{
        @Override
        public void draw() {
            System.out.println(" 绘制矩形 ");
        }
    }
    
    class Circle extends Shape{
        @Override
        public void draw() {
            System.out.println(" 绘制园形 ");
        }
    }
    class Triangle extends Shape{
        @Override
        public void draw() {
            System.out.println(" 绘制三角形 ");
        }
    }
    
    class OtherShape extends Shape{
        @Override
        public void draw() {
            System.out.println(" 绘制其他图形 ");
        }
    }

### 2.6迪米特法则 ###

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

举例：  
有一个学校， 下属有各个学院和总部， 现要求打印出学校总部员工 ID 和学院员工的 id

public class Demeter1 {
        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 employee = new CollegeEmployee();
                employee.setId("学院员工id="+i);
                list.add(employee);
            }
            return list;
        }
    }
    
    //学校管理类
    //直接朋友：Employee(方法返回值)，CollegeManager(方法参数)，
    //陌生朋友：CollegeEmployee （局部变量）
    class SchoolManager{
        //返回学校总部的员工
        public List<Employee>getAllEmployee(){
            List<Employee>list = new ArrayList<>();
            for (int i = 0; i <10 ; i++) {
                Employee employee = new Employee();
                employee.setId("学校总部员工id="+i);
                list.add(employee);
            }
            return list;
        }
    
        void printAllEmployee(CollegeManager sub){
            //获取到学院员工
            List<CollegeEmployee>list = sub.getAllEmployee();
            for (CollegeEmployee employee:list) {
                System.out.println(employee.getId());
            }
    
            //获取到学校总部员工
            List<Employee> allEmployee = this.getAllEmployee();
            for(Employee employee:allEmployee){
                System.out.println(employee.getId());
            }
        }
    }

根据迪米特法则改进：

public class Demeter1 {
        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 employee = new CollegeEmployee();
                employee.setId("学院员工id="+i);
                list.add(employee);
            }
            return list;
        }
    
        //改进时的新增方法
        public void printEmployee(){
            List<CollegeEmployee> allEmployee = getAllEmployee();
            for(CollegeEmployee employee:allEmployee){
                System.out.println(employee.getId());
            }
        }
    }
    
    //学校管理类
    class SchoolManager{
        //返回学校总部的员工
        public List<Employee>getAllEmployee(){
            List<Employee>list = new ArrayList<>();
            for (int i = 0; i <10 ; i++) {
                Employee employee = new Employee();
                employee.setId("学校总部员工id="+i);
                list.add(employee);
            }
            return list;
        }
    
        void printAllEmployee(CollegeManager sub){
            //改进时的方法：封装打印学院员工信息的方法到它自己类的内部去，遵循最少知道原则减少耦合
           sub.printEmployee();
    
            //获取到学校总部员工
            List<Employee> allEmployee = this.getAllEmployee();
            for(Employee employee:allEmployee){
                System.out.println(employee.getId());
            }
        }
    }

注意事项：

1.  迪米特法则的核心是降低类之间的耦合
2.  但是注意： 由于每个类都减少了不必要的依赖， 因此迪米特法则只是要求降低类间(对象间)耦合关系， 并不是  
    要求完全没有依赖关系

### 2.7 合成复用原则 ###

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

### 2.8 设计原则核心思想 ###

1.  找出应用中可能需要变化之处， 把它们独立出来， 不要和那些不需要变化的代码混在一起。
2.  针对接口编程， 而不是针对实现编程。
3.  为了交互对象之间的松耦合设计而努力

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTUwNzMyNA_size_16_color_FFFFFF_t_70]: /images/20230521/78ee98d5915640c191ea7ceb9f04b6f0.png