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

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


     传说有一天,神看到一个乞丐,动了怜悯之心。他对乞丐说,我将满足你的一个愿望,你要什么我会给你什么。说罢,怕乞丐不信,用手一指,乞丐面前出现了一个馒头;再一指,乞丐面前出现了一叠钱;再一指,乞丐面前出现了一队金砖。乞丐当然是看得目瞪口呆,神将那些收了回去,对乞丐说,说吧,你想要什么?乞丐回过神来,大喜道,我要你的那只手指。
     各位请看,这位聪明的乞丐是多么会使用面向对象的基本原则啊!他知道,无论要任何具体的东西,馒头、钱或者金子。其数量都是有限的,都会有尽头,如果花完了就不再有了;但是那只金手指却不一样,它虽然也只有一个,但是可以无穷尽的产生各种具体的东西。如果我们把各种具体的东西,如馒头、钱和金子比作对象,而把乞丐比如这个类的使用者、或者说依赖对象,而神的那只金手指则是那些具体对象的抽象;那么这个故事就讲述了面向对象的一个基本原则——依赖颠倒原则。它的意义在于阐述了这样一个道理:类的使用者或者说依赖者(乞丐)不能依赖某个具体的类(馒头、钱或金子),而要依赖于它们的抽象(金手指)。
      依赖颠倒原则:高层模块不应依赖于低层模块,两者都应该依赖于抽象;抽象不应该依赖于细节,细节应该依赖于抽象。
      很明显,遵从这个原则有三个主要的好处:一是扩展性好,可以随时增加一个实现了抽象类的具体类,而在类的使用者或依赖者不需要做任何改动。二是对被依赖类的使用的灵活性大大增加了,客户端可以在运行期决定使用哪一个具体类。三是代码的重用性好,所有的具体类都有统一的接口,那么客户端不必为每一个具体类写类似的代码。
      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接口就行。
      可以说依赖颠倒原则是面向对象的一个基础。这一原则在指导我们使用类的多态性,然后我们才获得了运行期绑定的能力。而这种能力是我们面向对象最有价值的技术之一。正是基于此,绝大多数的模式都要使用抽象来转移依赖,以达到优化设计的目的。
      在我们的面向对象的分析和设计过程中,我们总是在不停的减少和转移依赖,而这种减少和转移依赖的方法就是在依赖颠倒原则的指导下进行的。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页