设计原则

1. 单一职责原则

2. 里氏替换原则

继承的优点

  1. 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性
  2. 提高代码重用性
  3. 子类可以类似父类，但又异于父类
  4. 提高代码的可扩展性
  5. 提高产品或项目的开放性

继承的缺点

  1. 继承是入侵性的，只要继承，就必须拥有父类所有属性和方法
  2. 降低代码的灵活性
    8.增加了耦合性

里氏替换原则4个含义

  1. 子类必须完全回想父类法方法
  2. 子类可以有自己的个性
  3. 覆盖或实现父类方法时输入参数可以被放大

  4. 覆写或实现父类方法是输出结果可以被缩小

    则

    2.1继承的优点

    1. 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性
    2. 提高代码重用性
    3. 子类可以类似父类，但又异于父类
    4. 提高代码的可扩展性

    5. 提高产品或项目的开放性

      2.2 继承的缺点

    6. 继承是入侵性的，只要继承，就必须拥有父类所有属性和方法

    7. 降低代码的灵活性

    8. 增加了耦合性

      2.3 里氏替换原则4个含义

    9. 子类必须完全回想父类法方法

    10. 子类可以有自己的个性
    11. 覆盖或实现父类方法时输入参数可以被放大
    12. 覆写或实现父类方法是输出结果可以被缩小

      3. 依赖倒置

      3.1. 原则

  5. 高层模块不应该依赖底层模块，两者都应该依赖抽象
  • 每个逻辑的实现都是原子逻辑组成，不可分割的原子逻辑就是低层模块
  • 高层模块由底层逻辑组装成
  1. 细节不应该依赖细节
  • 抽象：接口或抽象类，两者不能直接被实例。
  • 细节：实现类，实现接口或继承抽象类而产生的类，可以直接被实例化
  1. 细节应该依赖抽象

    3.2 实现

  • 模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，依赖关系是通过接口或抽象类产生的
  • 接口或抽象类不依赖与实现类

  • 实现类依赖接口或抽象类

    3.3作用

  • 减少类间的耦合性，提高系统的稳定性

  • 降低并行开发引起的风险

  • 提高代码的可读性和可维护性

    3.4 依赖的三种写法

  • 只要做到抽象依赖，即使多层的依赖传递也没事

  • 方式：

    3.4.1构造器注入

    1. //构造函数传递依赖对象，在类中通过构造函数声明依赖对象
    2. public  interface interfaceName{
    3.         public void function();
    4.  }
    5. public  class ClassName implement interfaceName{
    6.         //关联
    7.         private interfaceName;
    8.         public ClassName(interfaceName _name){
    9.           //初始化 
    10.         }
    11.         public void function(){
    12.           //执行方法
    13.         }
    15. }

    3.4.2 setter方法注入

    ```java //接口注入：接口声明依赖的方式
    public interface InterfaceName{

    1.   //other function
    2. }
    3. public class ClassName implement InterfaceName{
    4.   //relation 
    5.   private InterfaceClassName className;
    6.   public void setAttitude(InterfaceClassName InterfaceClassName){
    7.     this.className=className;
    8.   }
    9.   //other function

    }

```

3.4.3 接口声明

  1. 接口声明依赖对象（接口注入）
  • 规则：
    • 每个类尽量都有接口或抽象类，或者抽象类和接口两者都具备
    • 变量的表面类型尽量是接口或抽象类
    • 任何类都不应该从具体类派生
    • 尽量不要复写基类的方法
    • 结合里氏替换原则使用
  • 解释：
    依赖正置：类间的依赖是实实在在的实现类间的依赖，也就是面向实现编程。（我开跑车就要依赖跑车）
    编写程序需要对现实世界的事物进行抽象，抽象的结果就是抽象类和接口，再根据设计的需要产生抽象间的依赖。
  • 优点：
    规避一些非技术因素引起的问题，减少需求变化引起的工作量剧增，可以让维护人员轻松地扩展和维护，是实现开闭原则的重要途径，只有实现依赖倒置，才可以实现对扩展开放，对修改关闭。
  • 要点：
    面向接口编程就抓住依赖倒置原则的核心

    3.4.4依赖倒置原则的本质

    每个类尽量都有接口或抽象类，或者抽象类和接口两者都具备

    4. 接口隔离原则

    4.1实例接口

  1. 对一个类型的事物的描述（可以new的对象）

    4.2类接口

  2. 使用interface关键字定义的接口

    4.3隔离

  3. 隔离是什么，如何隔离？

    1. 依赖它需要的接口，客户端需要什么接口就提供什么接口，把不需要的接口剔除
  4. 如何做？
    1. 建立单一接口，不要建立臃肿庞大的接口（尽量细化，同时减少接口中的方法）
  5. 保证接口的纯洁性
    1. 接口要尽量小
    2. 接口要高内聚，要求在接口中尽量少公布public ，接口是对外的承诺，承诺越少对系统的开发越有利，变更风险就越低，有利于降低成本
    3. 定制服务：单独为一个个体提供优良的服务
    4. 接口设计是有限度的
      1. 接口 的 设计 粒度 越小， 系统 越 灵活， 这是 不 争 的 事实。 但是， 灵活 的 同时 也 带来 了 结构 的 复杂化， 开发 难度 增加， 可维护性 降低

  6. 最佳实践规则

    1. 一个接口只服务于一个子模块或业务逻辑
    2. 通过业务逻辑压缩接口中的public方法，接口时常去回顾，尽量让接口精简
    3. 已经被污染的接口，尽量去修改，若变更的风险较大，则采用适配器模式进行转化处理
    4. 了解环境，拒绝盲从

      5.迪米特法则

  7. 最少知识原则LKP,一个对象应该对其他对象有最少的了解

  8. 我的信息你知道得越少越好（4个含义）
    1. 只和朋友交流