由模式谈对象对象的基本原则之依赖颠倒原则

“我要金手指”
——由模式谈对象对象的基本原则之依赖颠倒原则

传说有一天，神看到一个乞丐，动了怜悯之心。他对乞丐说，我将满足你的一个愿望，你要什么我会给你什么。说罢，怕乞丐不信，用手一指，乞丐面前出现了一个馒头；再一指，乞丐面前出现了一叠钱；再一指，乞丐面前出现了一队金砖。乞丐当然是看得目瞪口呆，神将那些收了回去，对乞丐说，说吧，你想要什么？乞丐回过神来，大喜道，我要你的那只手指。 各位请看，这位聪明的乞丐是多么会使用面向对象的基本原则啊！他知道，无论要任何具体的东西，馒头、钱或者金子。其数量都是有限的，都会有尽头，如果花完了就不再有了；但是那只金手指却不一样，它虽然也只有一个，但是可以无穷尽的产生各种具体的东西。如果我们把各种具体的东西，如馒头、钱和金子比作对象，而把乞丐比如这个类的使用者、或者说依赖对象，而神的那只金手指则是那些具体对象的抽象；那么这个故事就讲述了面向对象的一个基本原则——依赖颠倒原则。它的意义在于阐述了这样一个道理：类的使用者或者说依赖者（乞丐）不能依赖某个具体的类（馒头、钱或金子），而要依赖于它们的抽象（金手指）。 依赖颠倒原则：高层模块不应依赖于低层模块，两者都应该依赖于抽象；抽象不应该依赖于细节，细节应该依赖于抽象。 很明显，遵从这个原则有三个主要的好处：一是扩展性好，可以随时增加一个实现了抽象类的具体类，而在类的使用者或依赖者不需要做任何改动。二是对被依赖类的使用的灵活性大大增加了，客户端可以在运行期决定使用哪一个具体类。三是代码的重用性好，所有的具体类都有统一的接口，那么客户端不必为每一个具体类写类似的代码。 Composite（组合）模式是我们的一种常用模式，它是一种应用在“整体部分”的结构上一种模式。如我们将要说到的“树”就非常适合应用这种模式，因为叶子和树是一种典型的“部分与整体”的关系。下面我们来看看该模式是怎么来解决这个问题的。 首先定义一个接口： public interface TreeComponent { public void first(); public void middle(); public void rear(); public int deepth(); } 然后是叶子的实现： public class Leaf implements TreeComponent { private String leaf; public Leaf(String leaf) { this.leaf = leaf; } public void first() { System.out.println(leaf); } public void middle() { System.out.println(leaf); } public void rear() { System.out.println(leaf); } public int deepth() { return 1; } } 树的实现： public class Tree implements TreeComponent { private String treetop; private TreeComponent left; private TreeComponent right; public Tree(String treetop,TreeComponent left,TreeComponent right) { this.treetop = treetop; this.left = left; this.right = right; } public void first() { System.out.println(this.treetop); if(this.left!=null) { this.left.first(); } if(this.right!=null) { this.right.first(); } } public void middle() { if(this.left!=null) { this.left.middle(); } System.out.println(this.treetop); if(this.right!=null) { this.right.middle(); } } public void rear() { if(this.left!=null) { this.left.rear(); } if(this.right!=null) { this.right.rear(); } System.out.println(this.treetop); } public int deepth() { int ld = 0; int rd = 0; if(this.left!=null) { ld = this.left.deepth(); } if(this.right!=null) { rd = this.right.deepth(); } return (ld>rd?ld:rd)+1; } } 我们来看Tree类的两个依赖都是TreeComponent接口，满足依赖颠倒原则的低层应该依赖高层、细节应该依赖抽象的要求。这样做的好处是很明显的：使得树的左儿子和右儿子都既可以是叶子也可以是树，那么树的扩展性得到了很大的提高；而且在客户端使用时，树和叶子都可以使用同一个算法，减少了代码的重复。 命令模式、策略模式和状态模式的思路都一样：将关注点分离开来，使它们都实现统一的接口，然后再客户端进行调用。这样做的好处有很多：首先是分离了关注，满足了单一指责原则；然后是客户端由对细节的依赖转移到对抽象的依赖，这样使得系统的扩展性良好、能在运行期内使用关注。下面我们以命令模式来看看它怎么来遵从依赖颠倒原则的： 假如我们有如下代码： if(….) { //do action 1 …… } else if(…) { //do action 2 …… } else if(……) { //do action 3 …… } …… 很明显，客户端对细节的依赖很强。这样的代码都很多缺点：第一容易造成逻辑混乱，这么多的if…else…，而每一个动作都可能有复杂的逻辑，这样很容易造成混乱。第二不是动态绑定，需要事先确定有哪些动作。等等。 我们来将这些代码用命令模式来进行改造。 首先是做一个命令接口： public interface Common { public void doCommon(); } 然后用那些动作的代码来实现这个接口： public class Common1 implements Common { public void doCommon() { //do action 1 …… } } 其他的类如它类似，然后我们做一个工厂来生产这些具体的类： public class Factory { //这些类所在的路径 private String path = “……”; //生产具体类 public static Common getInstance(String type) { try { Class cls = Class.forName(this.path+type); Return (Common)cls. NewInstance() } catch(Exception e) { return null; } } } 最后我们的客户端调用就可以像这个样子： Common common = Factory.getInstance(type); Common.doCommon(); 这样，客户端依赖就由对细节的依赖转化为仅仅对抽象Common的依赖了，满足了依赖颠倒原则。类（Common接口和一些具体实现类）的作者可能并不知道客户端在运行期要调用那个具体实现类，可能不在他所作的那些具体实现类里，而是由使用者自己新增的实现类。由于需求的变化，使用者可能需要新增新的行为或动作，没关系，使用者只要实现Common接口就行。 可以说依赖颠倒原则是面向对象的一个基础。这一原则在指导我们使用类的多态性，然后我们才获得了运行期绑定的能力。而这种能力是我们面向对象最有价值的技术之一。正是基于此，绝大多数的模式都要使用抽象来转移依赖，以达到优化设计的目的。 在我们的面向对象的分析和设计过程中，我们总是在不停的减少和转移依赖，而这种减少和转移依赖的方法就是在依赖颠倒原则的指导下进行的。