设计模式的七大原则

设计模式的七大原则

一、单一职责原则

概念：一个类只负责一项功能，例如一个订单类，就只负责对订单的操作，不能去涉及到对用户或者商品的操作。(注意，一般情况下单一职责原则是作用于类上，但是如果一类的方法数量足够少，就可以把单一职责原则作用于方法上)

二、接口隔离原则

概念：客户端不应该依赖他不需要的接口，即一个类对另外一个类的依赖应该简历在最小接口上

三、依赖倒置原则

概念：

1. 高层模块不应该依赖低层模块，二者都应该依赖接口。
2. 抽象不应该依赖于细节，细节应该依赖于抽象。
3. 依赖倒置原则的核心思想就是（面向接口编程）。
4. 利用接口制定规范，然后用实现类来实现具体的任务。

案例

//方式1
public class Test {
    public static void main(String[] args) {
        ChangHongTv hongTv = new ChangHongTv();
        UseTv useTv = new UseTv();
        useTv.open(hongTv);
    }
}
class ChangHongTv implements Tv {
    @Override
    public void play() {
        System.out.println("长虹电视欢迎您");
    }
}

interface OpenAndClose {

    void open(Tv tv);
}

class UseTv implements OpenAndClose {

    @Override
    public  void open(Tv tv) {
        tv.play();
    }
}
interface Tv {
    void play();
}

//方式2 构造函数
public class Test2 {

    public static void main(String[] args) {
        ChangHongTv changHongTv = new ChangHongTv();

        UseTv2 useTv2 = new UseTv2(changHongTv);

        useTv2.open();
    }
}

interface OpenAndClose2 {
    void open();
}

interface Tv2 {
    void play();
}

class ChangHongTv2 implements Tv {
    @Override
    public void play() {
        System.out.println("长虹电视欢迎您");
    }
}

class UseTv2 implements OpenAndClose2 {

    private Tv tv;

    public UseTv2(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void open() {
        this.tv.play();
    }
}

//方式3 setter方法
public class Test3 {
    public static void main(String[] args) {
        ChangHongTv3 tv = new ChangHongTv3();
        UseTv3 useTv3 = new UseTv3();
        useTv3.setTv(tv);
        useTv3.open();
    }
}
interface OpenAndClose3 {
    void open();
}
interface Tv3 {
    void play();
}

class ChangHongTv3 implements Tv3 {
    @Override
    public void play() {
        System.out.println("长虹电视欢迎您");
    }
}

class UseTv3 implements OpenAndClose3 {
    private Tv3 tv;
    public void setTv(Tv3 tv) {
        this.tv = tv;
    }
    @Override
    public void open() {
        this.tv.play();
    }

    }
}

四、里氏替换原则

概念：

1. 如果对每个类型为T1的对象O1，都有类型为T2的对象O2，使得以T1定义的程序P在所有的对象O1替换成O2之后程序p的行为没有发送变化，那么T2是T1的子类型，换句话说（所有引用基类的地方必须能够透明的使用其子类的对象）
2. 在使用历史替换原则的时候，子类尽量不要重写父类的方法
3. 里氏替换原则告诉我们，继承实际上增加了程序的耦合度，在适当的情况下可以通过聚合，组合，依赖来解决问题。

/**
 * @author haizi
 * @Description 里氏替换原则
 * @create 2020-08-16 11:06
 */
public class LiskovDemo {
    public static void main(String[] args) {
        B b = new B();
        int i = b.fun2(3);
        int i1 = b.fun3(i, 3);
        System.out.println(i1);
    }
}

class Base {
}

class A extends Base {
    public int fun1(int a, int b) {
        return a - b;
    }
}

class B extends Base {

    private A a = new A();

    public int fun2(int a) {
        return a + 9;
    }

    public int fun3(int a, int b) {
        return this.a.fun1(a, b);

    }
}

五、开闭原则

概念：

1. 开闭原则是编程中最基础最重要的原则
2. 一个软件实体，如类，函数，模块应该对扩展开放，对修改关闭
3. 当软件需求发生变化时，尽量通过扩展软件实体的行为来实现变化，而不是修改已有的代码来实现方法

/**
 * @author haizi
 * @Description
 * @create 2020-08-16 16:11
 */
public class OCPDemo {

    public static void main(String[] args) {
        SharpEdit sharpEdit = new SharpEdit();
        sharpEdit.edit(new Triangle());
    }
}

abstract class Sharp {
    abstract void draw();
}

class Triangle extends Sharp {

    @Override
    void draw() {
        System.out.println("画三角形");
    }
}

class SharpEdit {
    public void edit(Sharp sharp) {
        sharp.draw();
    }
}

六、迪米特法则

概念：

1. 一个对象应该保持对其他对象最少的了解
2. 类与类关系越密切，耦合度越高
3. 迪米特法则，又叫最小知道法则，即一个类对自己依赖的对知道的越少越好。
4. 迪米特法则还有一个最简单你的定义（只与直接朋友通信）
5. 直接朋友：每个对象都对其他的对象有耦合关系，只要两个对象之间有耦合关系这两个对象就是朋友，耦合的方式有很多，依赖，关联，组合，聚合等，其中，我们称成员变量，方法参数，返回值中的类为直接朋友，而出现的局部变量中的类不是直接的朋友。

七、合成复用原则

概念：

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

总结（设计原则核心思想）：

1. 找出应用中可能需要变化的地方，把他们独立出来，不要和那些不需要变化的代码混合在一起
2. 针对接口编程，而不是针对实现编程
   象都对其他的对象有耦合关系，只要两个对象之间有耦合关系这两个对象就是朋友，耦合的方式有很多，依赖，关联，组合，聚合等，其中，我们称成员变量，方法参数，返回值中的类为直接朋友，而出现的局部变量中的类不是直接的朋友。

七、合成复用原则

概念：

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

总结（设计原则核心思想）：

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