WEB开发网
开发学院WEB开发Jsp 代码复用的规则 阅读

代码复用的规则

 2008-01-05 10:43:39 来源:WEB开发网   
核心提示:代码复用是绝大多数程序员所期望的,也是OO的目标之一,代码复用的规则,总结我多年的编码经验,为了使代码能够最大程度上复用,不要太深;例如:下面的接口定义了组件的功能:发送消息;类Transceiver实现了该接口;而其子类Pool只是治理多个Transceiver对象,而没有提供自己的接口实现,应该非凡注重以下几个方面

  代码复用是绝大多数程序员所期望的,也是OO的目标之一。总结我多年的编码经验,为了使代码能够最大程度上复用,应该非凡注重以下几个方面。
  1、 对接口编程
  "对接口编程"是面向对象设计(OOD)的第一个基本原则。它的含义是:使用接口和同类型的组件通讯,即,对于所有完成相同功能的组件,应该抽象出一个接口,它们都实现该接口。具体到java中,可以是接口(interface),或者是抽象类(abstract class),所有完成相同功能的组件都实现该接口,或者从该抽象类继续。我们的客户代码只应该和该接口通讯,这样,当我们需要用其它组件完成任务时,只需要替换该接口的实现,而我们代码的其它部分不需要改变!
  
  当现有的组件不能满足要求时,我们可以创建新的组件,实现该接口,或者,直接对现有的组件进行扩展,由子类去完成扩展的功能。
  
  2、 优先使用对象组合,而不是类继续
  "优先使用对象组合,而不是类继续"是面向对象设计的第二个原则。并不是说继续不重要,而是因为每个学习OOP的人都知道OO的基本特性之一就是继续,以至于继续已经被滥用了,而对象组合技术往往被忽视了。下面分析继续和组合的优缺点:
  
  类继续答应你根据其他类的实现来定义一个类的实现。这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。术语"白箱"是相对可视性而言:在继续方式中,父类的内部细节对子类可见。
  
  对象组合是类继续之外的另一种复用选择。新的更复杂的功能可以通过组合对象来获得。对象组合要求对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse),因为被组合的对象的内部细节是不可见的。对象只以"黑箱"的形式出现。
  
  继续和组合各有优缺点。类继续是在编译时刻静态定义的,且可直接使用,类继续可以较方便地改变父类的实现。但是类继续也有一些不足之处。首先,因为继续在编译时刻就定义了,所以无法在运行时刻改变从父类继续的实现。更糟的是,父类通常至少定义了子类的部分行为,父类的任何改变都可能影响子类的行为。假如继续下来的实现不适合解决新的问题,则父类必须重写或被其他更适合的类替换。这种依靠关系限制了灵活性并最终限制了复用性。
  
  对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。由于组合要求对象具有良好定义的接口,而且,对象只能通过接口访问,所以我们并不破坏封装性;只要类型一致,运行时刻还可以用一个对象来替代另一个对象;更进一步,因为对象的实现是基于接口写的,所以实现上存在较少的依靠关系。
  
  优先使用对象组合有助于你保持每个类被封装,并且只集中完成单个任务。这样类和类继续层次会保持较小规模,并且不太可能增长为不可控制的庞然大物(这正是滥用继续的后果)。另一方面,基于对象组合的设计会有更多的对象(但只有较少的类),且系统的行为将依靠于对象间的关系而不是被定义在某个类中。
  
  注重:理想情况下,我们不用为获得复用而去创建新的组件,只需要使用对象组合技术,通过组装已有的组件就能获得需要的功能。但是事实很少如此,因为可用的组件集合并不丰富。使用继续的复用使得创建新的组件要比组装已有的组件来得轻易。这样,继续和对象组合常一起使用。然而,正如前面所说,千万不要滥用继续而忽视了对象组合技术。
  
  相关的设计模式有:Bridge、Composite、Decorator、Observer、Strategy等。
  
  下面的例子演示了这个规则,它的前提是:我们对同一个数据结构,需要以任意的格式输出。
  
  第一个例子,我们使用基于继续的框架,可以看到,它很难维护和扩展。
  abstract class AbstractExampleDocument
  {
  // skip some code ...
  public void output(Example strUCture)
  {
  if( null != structure )
  {
  this.format( structure );
  }
  }
  PRotected void format(Example structure);
  }
  
  
  
  
  第二个例子,我们使用基于对象组合技术的框架,每个对象的任务都清楚的分离开来,我们可以替换、扩展格式类,而不用考虑其它的任何事情。
  class DefaultExampleDocument
  {
   // skip some code ...
   public void output(Example structure)
   {
   ExampleFormatter formatter =
   (ExampleFormatter) manager.lookup(Roles.FORMATTER);
   if( null != structure )
   {
   formatter.format(structure);
   }
   }
  }
  
  
  这里,用到了类似于"抽象工厂"的组件创建模式,它将组件的创建过程交给manager来完成;ExampleFormatter是所有格式的抽象父类;
  
  3、 将可变的部分和不可变的部分分离
  "将可变的部分和不可变的部分分离"是面向对象设计的第三个原则。假如使用继续的复用技术,我们可以在抽象基类中定义好不可变的部分,而由其子类去具体实现可变的部分,不可变的部分不需要重复定义,而且便于维护。假如使用对象组合的复用技术,我们可以定义好不可变的部分,而可变的部分可以由不同的组件实现,根据需要,在运行时动态配置。这样,我们就有更多的时间关注可变的部分。
  
  对于对象组合技术而言,每个组件只完成相对较小的功能,相互之间耦合比较松散,复用率较高,通过组合,就能获得新的功能。
  
  4、 减少方法的长度
  通常,我们的方法应该只有尽量少的几行,太长的方法会难以理解,而且,假如方法太长,则应该重新设计。对此,可以总结为以下原则:
  
  三十秒原则:
  假如另一个程序员无法在三十秒之内了解你的函数做了什么(What),如何做(How)以及为什么要这样做(Why),那就说明你的代码是难以维护的,必须得到提高;
  一屏原则:
  假如一个函数的代码长度超过一个屏幕,那么或许这个函数太长了,应该拆分成更小的子函数;
  一行代码尽量简短,并且保证一行代码只做一件事
  
  那种看似技巧性的冗长代码只会增加代码维护的难度。
  
  5、 消除case / if语句
  要尽量避免在代码中出现判定语句,来测试一个对象是否某个特定类的实例。通常,假如你需要这么做,那么,重新设计可能会有所帮助。我在工作中碰到这样的一个问题:我们在使用JAVA做xml解析时,对每个标签映射了一个JAVA类,采用SAX(简单的XML接口API:Simple API for XML)模型。结果,代码中反复出现了大量的判定语句,来测试当前的标签类型。为此,我们重新设计了DTD(文档类型定义:Document Type Definition),为每个标签增加了一个固定的属性:classname,而且重新设计了每个标签映射的JAVA类的接口,统一了每个对象的操作: addElement(Element aElement); //增加子元素
  addAttribute(String attName, String attValue); //增加属性;
  
  则彻底消除了所有的测试当前的标签类型的判定语句。每个对象通过 Class.forName(aElement.attributes.getAttribute("classname")).newInstence(); 动态创建,
  
  6、 减少参数个数
  有大量参数需要传递的方法,通常很难阅读。我们可以将所有参数封装到一个对象中来完成对象的传递,这也有利于错误跟踪。
  
  许多程序员因为,太多层的对象包装对系统效率有影响。是的,但是,和它带来的好处相比,我们宁愿做包装。究竟,"封装"也是OO的基本特性之一,而且,"每个对象完成尽量少(而且简单)的功能",也是OO的一个基本原则。
  
  7、 类层次的最高层应该是抽象类
  在许多情况下,提供一个抽象基类有利做特性化扩展。由于在抽象基类中,大部分的功能和行为已经定义好,使我们更轻易理解接口设计者的意图是什么。
  
  由于JAVA不答应"多继续",从一个抽象基类继续,就无法再从其它基类继续了。所以,提供一个抽象接口(interface)是个好主意,一个类可以实现多个接口,从而模拟实现了"多继续",为类的设计提供了更大的灵活性。
  
  8、 尽量减少对变量的直接访问
  对数据的封装原则应该规范化,不要把一个类的属性暴露给其它类,而是应该通过访问方法去保护他们,这有利于避免产生波纹效应。假如某个属性的名字改变,你只需要修改它的访问方法,而不是修改所有相关的代码。
  
  9、 子类应该特性化,完成非凡功能
  假如一个子类只是使一个组件变成组件治理器,而不是实现接口功能,或者,重载某个功能,那么,就应该使用一个外部的容器类,而不是创建一个子类。
  
  建议:类层次结构图,不要太深;
  
  例如:下面的接口定义了组件的功能:发送消息;类Transceiver实现了该接口;而其子类Pool只是治理多个Transceiver对象,而没有提供自己的接口实现。建议使用组合方式,而不是继续!
  public interface ITransceiver{
   public abstract send(String msg);
  }
  
  public class Transceiver implements ITransceiver {
   public send(String msg){
   System.out.println(msg);
   }
  }
  
  //使用继续方式的实现
  public class Pool extends Transceiver{
   private List pool = new Vector();
   public void add(Transceiver aTransceiver){
   pool.add(aTransceiver);
  }
  public Transceiver get(int index){
   pool.get(index);
  }
  }
  
  //使用组合方式的实现
  public class Pool {
   private List pool = new Vector();

Tags:代码 复用 规则

编辑录入:爽爽 [复制链接] [打 印]
赞助商链接