一文搞懂面向对象6大原则

一文搞懂确实有点难度，我尽量做到通俗易懂、逻辑严谨、论证精彩、案例丰富、极富启发性。

一，开篇

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

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

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


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

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

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

六大基本原则分别是：

1. 开闭原则
2. 依赖倒置原则
3. 里氏替换原则
4. 单一职责原则
5. 接口隔离原则
6. 迪米特原则
   
   

二，详解6大基本原则

1，开闭原则

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

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

$举个常见的例子$，在一个系统建设初期，可能只有一个数据源，假设是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，依赖倒置

$什么是依赖倒置，倒置是什么意思？$

先来看看官方定义：

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

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

按照这个思路，针对前面的例子，做如下改造：

$首先，要定义一个操作数据源的接口或者抽象类。$

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

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

$其次，客户端要面向接口编程，要引用接口，不要引用具体的实现类。$

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，里氏替换原则

官方定义：

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

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

$“依赖倒置原则”是写代码过程中要遵循的原则$，$“里氏替换原则”用来检验写出来的代码有没有遵循原则$。

贯彻了依赖倒置，自然就达到了里氏替换的要求。

public interface BaseDao<T> {
    public void insert(T t);
    public List<T> findAll(T t );
}

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, 类的单一职责