面向对象七大原则

1. 单一职责原则

   即一个类应该只负责一项职责。(在方法级别上约束只做一件事或在类级别上约束只做一件事。只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则)

   优点：降低类的复杂度；提高类的可读性；降低变更引起的风险。

2. 接口隔离原则

   即一个类对另一个类的依赖应该建立在最小的接口上。

   demo：一个接口InterfaceA，两个类B、C依赖接口A，类D、E依赖接口A，但D只依赖接口A中的1,2,3方法，E只依赖接口A的1,4,5方法。类图描述如下：

    

   ① 不遵循接口隔离原则的代码：

   public interface InterfaceA {
   ​
       void method1();
   ​
       void method2();
   ​
       void method3();
   ​
       void method4();
   ​
       void method5();
   }

   public class B implements InterfaceA{
       @Override
       public void method1() {
           System.out.println("method1--B");
       }
   ​
       @Override
       public void method2() {
           System.out.println("method2--B");
       }
   ​
       @Override
       public void method3() {
           System.out.println("method3--B");
       }
   ​
       @Override
       public void method4() {
           System.out.println("method4--B");
       }
   ​
       @Override
       public void method5() {
           System.out.println("method5--B");
       }
   }

   public class C implements InterfaceA{
       @Override
       public void method1() {
           System.out.println("method5--C");
       }
   ​
       @Override
       public void method2() {
           System.out.println("method5--C");
       }
   ​
       @Override
       public void method3() {
           System.out.println("method5--C");
       }
   ​
       @Override
       public void method4() {
           System.out.println("method5--C");
       }
   ​
       @Override
       public void method5() {
           System.out.println("method5--C");
       }
   }

   public class D{
   ​
       void dependMethod1(InterfaceA i){
           i.method1();
       }
   ​
       void dependMethod2(InterfaceA i){
           i.method2();
       }
   ​
       void dependMethod3(InterfaceA i){
           i.method3();
       }
   }

   public class E {
   ​
       void dependMethod1(InterfaceA i){
           i.method1();
       }
   ​
       void dependMethod2(InterfaceA i){
           i.method4();
       }
   ​
       void dependMethod3(InterfaceA i){
           i.method5();
       }
   }

   ② 接口隔离后的代码：

   UML类图如下：

    

   代码如下：

   public interface InterfaceA {
       void method1();
   }

   public interface InterfaceB extends InterfaceA{
       void method2();
       void method3();
   }

   public interface InterfaceC extends InterfaceA {
       void method4();
       void method5();
   }

   public class D{
   ​
       void dependMethod1(InterfaceB bi){
           bi.method1();
       }
   ​
       void dependMethod2(InterfaceB bi){
           bi.method2();
       }
     
       void dependMethod3(InterfaceB bi){
           bi.method3();
       }
   }

   public class E {
   ​
       void dependMethod1(InterfaceC ci){
           ci.method1();
       }
   ​
       void dependMethod2(InterfaceC ci){
           ci.method4();
       }
   ​
       void dependMethod3(InterfaceC ci){
           ci.method5();
       }
   }
   

3. 依赖倒置原则

   高层模块不应该依赖低层模块，二者都应该依赖其抽象；

   抽象不应该依赖细节，细节应该依赖抽象；

   依赖倒置的中心思想是面向接口编程；

   使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

   依赖关系传递的3种方式：

   ① 接口传递

   ② 构造器传递

   ③ setter方法传递

4. 里氏替换原则

   所有引用基类的地方必须能够透明地使用其子类的对象；

   使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法；

   继承实际上增强了两个类的耦合性，适当情况下，可以通过聚合、组合、依赖的方式来解决。

5. 开闭原则

   一个软件实体，比如类、模块、函数应该对扩展开放，对修改关闭。用抽象构建框架，用实现扩展细节；

   当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

6. 迪米特法则

   一个对象应该对其它对象保持最少的了解；

   类与类关系越密切，耦合度越大；

   一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外除了提供public方法，不对外泄露任何信息。

7. 合成复用原则

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