设计模式-六种设计原则

刺骨的言语ヽ痛彻心扉 2023-03-04 14:27 20阅读 0赞

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

> 降低类的复杂度，一个类只负责一个职责。
> 
> 提高代码的可读性、可维护性。
> 
> 降低代码变更引起的风险。
> 
> 通常情况下：应该遵守单一职责原则，只有在逻辑足够简单可以违反单一职责原则，可以在方法级别保持单一职责。

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

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

例如

有接口1,此时在接口1中有方法1、方法2、方法3、方法4、方法5。

有类A、B实现了接口1，但是A只会用到方法1、2、3，方法B只会用到方法1、4、5。

接口隔离原则改进：

将接口1分离成三个接口，接口1含有方法1、接口2有方法2、3，接口3有方法4、5。

类A实现接口1、接口2

类B实现接口1、接口3

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

> 高层模块不应该依赖底层模块，二者都应该依赖其抽象
> 
> 抽象不应该依赖细节、细节应该依赖抽象
> 
> 依赖倒转的中心思想是面向接口编程。

实现依赖倒转的三种方式

现有电视机接口和遥控器接口

Changhong实现了电视机接口，

remote实现遥控器接口

可以根绝遥控器的open方法打开电视机，此时在遥控器中依赖了电视机

方式一：利用方法参数（接口）依赖传递

//电视机接口
    interface ITv{ 
        void play();
    }
    //遥控器接口
    interface IRemoteTv{ 
        //在方法参数中传递接口
        void open(ITv iTv);
    }
    class Remote implements IRemoteTv{ 
        public void open(ITv iTv) { 
            iTv.play();
        }
    }
    class Changhong implements ITv{ 
    
        public void play() { 
            System.out.println("打开电视机");
        }
    }

方式二：利用构造函数依赖传递

interface IRemoteTv{ 
        void open();
    }
    class Remote implements IRemoteTv{ 
        private ITv iTv;
        //使用构造传递依赖
        public Remote(ITv iTv){ 
            this.iTv = iTv;
        }
        public void open() { 
            iTv.play();
        }
    }

方式三：利用setter方法依赖传递

class Remote implements IRemoteTv{ 
        private ITv iTv;
    	//使用set方法传递依赖
        public void setiTv(ITv iTv){ 
            this.iTv = iTv;
        }
        public void open() { 
            iTv.play();
        }
    }

### 4.里式替换原则 ###

> 使用基类的地方能够透明的使用子类的对象。也就是说子类不应该重写父类的方法，应该和父类的方法保持透明。
> 
> 继承会使两个类的耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。
> 
> **子类实现父类的抽象方法时，入参条件要比父类更加严格（父类方法参数为Map子类可以HashMap），这样用父类替换子类和子类替换父类都是透明的**
> 
> **子类实现父类的普通方法时，入参条件，要比父类更加的宽松，这样相当于对父类方法的重载**

注意：重写父类的方法会对程序有侵入性。可能重写是无意的，但是如何解决？

例如

public static void main(String[] args) { 
            Calculate calculate = new ChildCalculate();
        	//由于子类重写了方法，此时程序被入侵破坏，此时并不是加法运算
            calculate.add(3,2);
        }
    
    class Calculate{ 
        protected void add(int a,int b){ 
            System.out.println(a+b);
        }
    }
    class ChildCalculate extends Calculate{ 
    	//重写父类方法
        protected void add(int a,int b){ 
            System.out.println(a -b);
        }
    }

解决方式：

让这两个类成为兄弟类，使用组合或者聚合。

class Base{ }
    
    class Calculate extends Base{ 
    
        protected void fun1(int a,int b){ 
            System.out.println(a - b);
        }
       protected void fun2(int a,int b){ 
            System.out.println(a + b);
        }
    
    }
    class MyCalculate extends Base{ 
        Calculate calculate = new Calculate();
        public void fun3(int a,int b){ 
            calculate.fun2(a,b);
        }
    
    }

### 5.开闭原则 ###

> 最基础，最重要的设计原则
> 
> 模块、工程：对扩展是开放(提供方)，对修改是关闭(使用方)
> 
> 当程序发生变化时，应该通过行为实现扩展而不是修改原有代码

//当新增一个图形时
    //客户端调用方--不需要修改代码
    class DrawGriphix{ 
        void drawPhix(Shape shape){ 
            shape.draw();
        }
    
    }
    //服务方也不需要修改代码-只需要增加一个类即可
    interface Shape{ 
        void draw();
    }
    class Triangle implements Shape{ 
        public void draw() { 
            System.out.println("画三角形");
        }
    }
    class Circle implements Shape{ 
    
        public void draw() { 
            System.out.println("画圆形");
        }
    }

### 6.迪米特法则 ###

> 一个类对依赖的类要遵循最小知道原则。
> 
> 只与直接朋友通信。

直接朋友：

每个对象都会与其他对象有耦合关系。耦合的方式很多比如依赖、组合、聚合、关联等。其中我们称出现成员变量，方法参数，返回值中的类为直接朋友，而出现在局部变量中的类不是直接朋友。也就是说陌生的类最好不要以局部变量出现在其他类的内部。

核心：降低类的耦合，并不是完全没有依赖关系。

### 7.和重复用原则 ###

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

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

> 找出应用中的变化之处，将变化独立出来，不要和变化的代码混合在一起
> 
> 针对接口编程，而不是针对实现变成，
> 
> 为了交互对象之间的松耦合设计而努力。