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

一、单一职责原则

• 一个类应该只负责一项职责。
• 这一点是关于类的粒度的描述。
• 降低类的复杂度，一个类只负责一项职责
• 提高类的可读性，可维护性
• 降低变更引起的风险
• 通常情况下，我们应当遵循单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则。

二、 接口隔离原则

• 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
• 如下代码，在Class1和Class2在实现接口时，两个类中均存在了冗余的未实现方法，不满足接口隔离原则。

// 未优化
interface Interface{
    public void function1();
    public void function2();
    public void function3();
}
class Class1 implements Interface{

    @Override
    public void function1() {
        System.out.println("I have function1");
    }

    @Override
    public void function2() {
        System.out.println("I have function2");
    }

    @Override
    public void function3() {
        /*
        * void 
        * */
    }
}
class Class2 implements Interface{

    @Override
    public void function1() {
        /*
        * void
        * */
    }

    @Override
    public void function2() {
        /*
         * void
         * */
    }

    @Override
    public void function3() {
        System.out.println("I have function3");
    }
}

• 采用接口隔离后

// 优化后
interface Interface1{
    public void function1();
    public void function2();
}

interface Interface2{
    public void function3();
}
class Class1 implements Interface1{

    @Override
    public void function1() {
        System.out.println("I have function1");
    }

    @Override
    public void function2() {
        System.out.println("I have function2");
    }
    
}
class Class2 implements Interface2{
    
    @Override
    public void function3() {
        System.out.println("I have function3");
    }
}

三、依赖倒转原则

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

// 方式一
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.如果获取对象是 微信、短信，则新增类，同时Person也要增加相应的接收方法
// 3.解决思路：引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖
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());
    }
}

class Email implements IReceiver{

    @Override
    public String getInfo(){
        return "电子邮件的信息： Hello,world";
    }
}

interface IReceiver{
    public String getInfo();
}

class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

依赖传递的三种方式

• 接口传递
• 构造器传递
• setter方法传递

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

• 底层模块尽量都要抽象类或者接口，或者两者都有，程序稳定性更好；
• 变量的声明类型尽量是抽象类和接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利用程序扩展和优化。

四、里氏替换原则

• 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。
• 在子类中尽量不要重写父类的方法，因为继承会形成一种较强的耦合度，因此在适当情况下，可以使用 聚合、组合、依赖 来解决问题。

五、开闭原则

• 开闭原则是编程中最基础、最重要的设计原则；
• 一个软件实体如类，模块和函数应该对扩展开放（对提供方），对修改关闭（使用方）；
• 用抽象构建框架，用实现扩展细节；
• 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化；

六、迪米特法则

• 一个对象应该对其他对象保持最少的了解；
• 类与类关系越密切，耦合度越大；
• 迪米特法则，即一个类对自己依赖的类知道的越少越好。对于被依赖的类不管多复杂，都尽量将逻辑封装在类的内部。对外通过public来提供信息。

七、合成复用原则

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