设计模式-六种设计原则

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.和重复用原则

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

设计原则的核心思想

找出应用中的变化之处，将变化独立出来，不要和变化的代码混合在一起

针对接口编程，而不是针对实现变成，

为了交互对象之间的松耦合设计而努力。