依赖抽象，不依赖具体实现

一文搞懂面向对象6大原则_依赖接口不依赖实现-CSDN博客

请访问如上原文

读后感

1，开闭原则

开闭原则是6大原则之首，是带头大哥，其余5个原则的最终目的都是为了实现开闭。

2，依赖倒置

先来看看官方定义：

依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

这个原则要求客户端在使用api时要使用接口或者父类，而不要直接使用具体的实现类。

一，开篇

有点追求的攻城狮可能会遇到以下两种场景：

一 是 \color{red}{一是}一是看到一段代码，大呼牛叉，忍不住推荐给同事看看，同事问好在哪里，结果一脸懵逼，竟说不出哪里好！

二 是 \color{red}{二是}二是自以为写了一段牛逼的代码，上线之后却bug不断，被同事吐槽“垃圾”。

欣赏不来优秀的代码，又写不出好代码，你注定是屌丝一枚，只能成为一只“独孤身”啊。

但是，这一切都是可以改变的，只要我们掌握并运用一些基本的原则和方法。

其中，面向对象的6大原则是最基本和常见的。

六大基本原则分别是：
开闭原则
依赖倒置原则
里氏替换原则
单一职责原则
接口隔离原则
迪米特原则

二，详解6大基本原则

1，开闭原则
开闭原则是6大原则之首，是带头大哥，其余5个原则的最终目的都是为了实现开闭。

开闭原则的经典解释就是：对修改关闭，对扩展开放。

举 个 常 见 的 例 子 \color{red}{举个常见的例子}举个常见的例子，在一个系统建设初期，可能只有一个数据源，假设是Oracle。

我们的持久层可以写成这样：

public class OracleOperator<T> {
     public List<T> list(T t) {
         // 连接数据库
         // 查询数据库
         // 关闭连接
         // 返回结果
      }

      public int insert(T t) {
         // 连接数据库
         // 插入数据
         // 关闭连接
         // 返回结果
      }
   
      // 以下省略各种增删改查
      // ...
}

那你的客户端代码很可能长成这样：

  public class Business{
         private OracleOperator oracleOperator;
         public int save(Goods goods) {
                // whatever other code
               return oracleOperator.insert(goods)
         }

         public List<Goods> list(Goods goods) {
                // whatever other code
               return oracleOperator.list(goods)
         }
  }

然后，公司高层大手一挥，决定去oracle化，上mysql。

好吧，你有了新的持久层，是这样的：

public class MySqlOperator<T> {
     public List<T> list(T t) {
         // 连接数据库
         // 查询数据库
         // 关闭连接
         // 返回结果
      }

      public int insert(T t) {
         // 连接数据库
         // 插入数据
         // 关闭连接
         // 返回结果
      }
   
      // 以下省略各种增删改查
      // ...
}

糟糕了，客户端代码也要改了：

  public class Business{
         private MySqlOperator mySqlOperator;
         public int save(Goods goods) {
                // whatever other code
               return mySqlOperator.insert(goods)
         }

         public List<Goods> list(Goods goods) {
                // whatever other code
               return mySqlOperator.list(goods)
         }
  }

显然，一旦持久层发生变化，客户端也要随之变化。

我们希望做到的是，不管你的数据源是增加还是减少，客户端的代码都能保持不变。

既满足所谓的对扩展开放(此处指数据源，你可以用任何你想用的数据源)，对修改关闭（此处指使用数据源的客户端代码）。

如何优化上文提到的代码以达到“开闭”的要求呢？

这就涉及到其他几个原则啦。

2，依赖倒置

什 么 是 依 赖 倒 置 ， 倒 置 是 什 么 意 思 ？ \color{red}{什么是依赖倒置，倒置是什么意思？}什么是依赖倒置，倒置是什么意思？

先来看看官方定义：

依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

这个原则要求客户端在使用api时要 \color{red}{要}要使用接口或者父类，而不 要 \color{red}{不要}不要直接使用具体的实现类。
按照这个思路，针对前面的例子，做如下改造：

首 先 ， 要 定 义 一 个 操 作 数 据 源 的 接 口 或 者 抽 象 类 。 \color{green}{首先，要定义一个操作数据源的接口或者抽象类。}首先，要定义一个操作数据源的接口或者抽象类。

public class DbOperatorInterface<T> {
      List<T> list(T t)；

      int insert(T t) ；
   
      // 以下省略各种增删改查
      // ...
}

其 次 ， 客 户 端 要 面 向 接 口 编 程 ， 要 引 用 接 口 ， 不 要 引 用 具 体 的 实 现 类 。 \color{green}{其次，客户端要面向接口编程，要引用接口，不要引用具体的实现类。}其次，客户端要面向接口编程，要引用接口，不要引用具体的实现类。

public class Business{
         // 依赖于接口，不依赖于具体实现 
         private DbOperatorInterface operator;
   
         public Business(DbOperatorInterface operator) {
                  this.operator = operator;
         }
         
         public int save(Goods goods) {
                // whatever other code
               return operator.insert(goods)
         }

         public List<Goods> list(Goods goods) {
                // whatever other code
               return operator.list(goods)
         }
  }

再看看接口的具体实现类：

public class OracleOperator implements DbOperatorInterface {
     public List<T> list(T t) {
         // 连接数据库
         // 查询数据库
         // 关闭连接
         // 返回结果
      }

      public int insert(T t) {
         // 连接数据库
         // 插入数据
         // 关闭连接
         // 返回结果
      }
   
      // 以下省略各种增删改查
      // ...
}

如果要从oracle切换到mysql，只要实现一个继承了接口的mysql操作类，将这个类的实现注入到Business类中，而不需要改动Business的代码

public class MysqlOperator implements DbOperatorInterface {
      // 以下省略各种增删改查
      // ...
}
这样，我们就达到了“开闭原则“的要求。

最后，来解释下”依赖倒置“中的”倒置“是什么意思。

看看上面例子的类的继承结构图。

这是一个倒着的树状结构图，我们都知道，运行时起作用的是这棵树下层的具体实现类，但为了实现”开闭“，不能依赖具体实现类，而要依赖上层的接口或者抽象类，这就是”倒置“的意思。

3，里氏替换原则

官方定义：
所有引用基类的地方必须能透明地使用其子类的对象。

这个原则理解起来不是很难，按照“依赖倒置原则”，写代码时要依赖基类，实际代码运行时，执行的是子类对象，就是要求做到这点。

“ 依 赖 倒 置 原 则 ” 是 写 代 码 过 程 中 要 遵 循 的 原 则 \color{green}{“依赖倒置原则”是写代码过程中要遵循的原则}“依赖倒置原则”是写代码过程中要遵循的原则，“ 里 氏 替 换 原 则 ” 用 来 检 验 写 出 来 的 代 码 有 没 有 遵 循 原 则 \color{green}{“里氏替换原则”用来检验写出来的代码有没有遵循原则}“里氏替换原则”用来检验写出来的代码有没有遵循原则。
贯彻了依赖倒置，自然就达到了里氏替换的要求。

public interface BaseDao<T> {
    public void insert(T t);
    public List<T> findAll(T t );
}
1
2
3
4
public class MysqlDao<T> implements  BaseDao<T>{
    public void insert(T t){}
    public List<T> findAll(T t ){}
}

public class OracleDao<T> implements  BaseDao<T>{
    public void insert(T t){}
    public List<T> findAll(T t ){}
}

客户端代码：

public class UserServiceImpl {
   private BaseDao baseDao;
    public void saveUser() {
          baseDao.save(new User());
          // 以下两种替换都是必须要可以的
          // oracleDao.save(new User());
          // mysqlDao.save(new User());
    }
}

按照里氏替换原则要求，baseDao出现的地方必须能够被MysqlDao和OracleDao的对象替换，还不能有异常。

4，单一职责原则

单一职责的官方定义：

不要存在多于一个导致类变更的原因
一个类/接口/方法只负责一项职责

单一职责可以分为两类：

1. 类的单一职责
2. 接口的单一职责
1
2
1, 接口的单一职责
2, 类的单一职责
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/epitomizelu/article/details/101094734