`
junli0411
  • 浏览: 139699 次
  • 来自: ...
社区版块
存档分类
最新评论

面向对象之代码复用规则

阅读更多
 代码复用是绝大多数程序员所期望的,也是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();
    public void add(Transceiver aTransceiver){
      pool.add(aTransceiver);
    }
    public Transceiver get(int index){
      pool.get(index);
    }
  }

 

10、 拆分过大的类。
 
  如果一个类有太多的方法(超过50个),那么它可能要做的工作太多,我们应该试着将它的功能拆分到不同的类中,类似于规则四。

11、 作用截然不同的对象应该拆分。
 
  在构建的过程中,你有时会遇到这样的问题:对同样的数据,有不同的视图。某些属性描述的是数据结构怎样生成,而某些属性描述的是数据结构本身。最好将这两个视图拆分到不同的类中,从类名上就可以区分出不同视图的作用。类的域、方法也应该有同样的考虑!

12、 尽量减少对参数的隐含传递。
 
  两个方法处理类内部同一个数据(域),并不意味着它们就是对该数据(域)做处理。许多时候,该数据(域)应该作为方法的参输入数,而不是直接存取,在工具类的设计中尤其应该注意。例如:
  public class Test{
    private List pool = new Vector();
    public void testAdd(String str){
      pool.add(str);
    }
    public Object testGet(int index){
      pool.get(index);
    }
  }

 

  两个方法都对List对象pool做了操作,但是,实际上,我们可能只是想对List接口的不同实现Vector、ArrayList等做存取测试。所以,代码应该这样写:
  public class Test{
    private List pool = new Vector();
    public void testAdd(List pool, String str){
      pool.add(str);
    }
    public Object testGet(List pool, int index){
      pool.get(index);
    }
  }

 

参考资料
设计模式
apache 小组的jakarta 项目的Avalon子项目(http://jakarta.apache.org/),是关于代码复用的,Commons子项目(http://jakarta.apache.org/commons/index.html)也有部分内容。

Thinking in Java

(转载文章请保留出处:北天JAVA技术网(www.java114.com))

分享到:
评论

相关推荐

    设计模式:可复用的面向对象软件的基础

    设计模式是指在面向对象软件开发中,针对特定问题而设计的解决方案模板,它们是经过时间检验的最佳实践,可以帮助开发者构建灵活、易维护且可复用的软件系统。掌握设计模式对游戏引擎的开发尤其重要,因为游戏引擎...

    面向对象之人机猜拳

    面向对象编程是软件开发中的一个重要概念,它模拟真实世界中的对象和它们之间的关系,使得代码更具有可读性、可维护性和复用性。在这个"面向对象之人机猜拳"项目中,我们将深入探讨如何利用面向对象的思想来设计和...

    面向对象和面向过程的区别

    继续以五子棋为例,面向对象的设计会将游戏中的玩家、棋盘和规则视为三个不同的对象,玩家对象处理用户输入,棋盘对象负责绘制和更新棋局状态,规则对象则负责判断游戏规则。这种设计方式使得代码更具有模块化,更...

    控制台面向对象飞行棋

    在计算机编程领域,面向对象编程(Object-Oriented Programming,OOP)是一种重要的编程范式,它基于“对象”的概念,将数据和处理数据的方法封装在一起,使得代码更加模块化和易于管理。本项目“控制台面向对象飞行...

    js写的象棋(面向对象)

    面向对象编程(Object-Oriented Programming, OOP)是一种软件开发方法,它将数据和操作数据的方法封装在对象中,以提高代码的可读性、可维护性和复用性。在这个项目中,我们可以期待看到不同的对象,如棋盘、棋子、...

    用面向对象思想实现人机猜拳游戏。

    整个项目通过面向对象的设计,将游戏的各个部分解耦,使得代码更易于理解和维护。用户类和计算机类代表游戏参与者,Game类作为游戏逻辑的中心,它们之间的交互体现了OOP中的协作和消息传递。同时,通过枚举和抽象...

    面向对象方法的大鱼喂小鱼~ 有关卡!

    良好的面向对象设计应该鼓励代码重用,例如通过创建一个可扩展的`Level`类,开发者可以轻松地添加新的关卡或修改现有关卡的特性,而不必对整个游戏逻辑进行大幅度改动。 音乐元素也是游戏体验的一部分。在面向对象...

    结构化程序设计方法与面向对象程序设计方法之比较.

    通过封装、继承和多态等机制,面向对象设计能够创建灵活且可复用的代码结构,从而提高软件的可维护性和可扩展性。 ### 概念或术语名词 **结构化设计**:涉及到的过程、函数和数据等基本概念,这些元素构成了程序的...

    js一般方法改写成面向对象方法的无限级折叠菜单示例代码

    面向对象的编程鼓励模块化和代码重用,使我们能够构建具有复杂结构和行为的程序。 根据描述,原先的无限级折叠菜单是使用一般方法编写的。一般方法通常指的是过程式的编程方式,即编写一系列的步骤来实现特定的功能...

    Java面向对象程序设计

    Java面向对象程序设计是计算机编程领域中的核心主题,它基于面向对象编程(OOP)理念,使得代码更具有模块化、可复用性和易于维护的特点。以下是对标题和描述中涉及的知识点的详细阐述: 1. **第1章:Java入门** -...

    俄罗斯方块面向对象版

    继承则允许我们重用已有类的属性和方法,减少代码重复,提高代码复用性。 在实现过程中,我们还需要考虑游戏逻辑的处理,如方块的移动、消除行、得分计算等。这些可以通过定义对象间的交互和事件驱动的方式来实现。...

    面向对象的程序设计语言与面向过程的程序设计语言.docx

    如同五子棋游戏,面向过程会按步骤设计,而面向对象则会创建“玩家”、“棋盘”和“规则”等类,让它们各自负责相应的功能。 面向对象设计有三个关键原则:封装、继承和多态。封装使得对象的状态(数据)和行为...

    Java面向对象编程实现骑士飞行棋小游戏源代码

    6. **封装**:面向对象编程的重要原则之一是封装,它隐藏了对象内部的实现细节,只暴露必要的接口供外部调用。例如,地图类可能只允许通过特定的方法来修改棋盘状态,而不是直接访问棋盘数组。 7. **多态**:多态性...

    广州大学面向对象程序设计1-7实验报告.zip

    继承允许一个类(子类)从另一个类(父类)中继承属性和行为,从而实现代码复用和层次结构的构建。多态性则提供了不同对象对同一消息做出不同响应的能力,通常通过虚函数实现,它增强了程序的灵活性和扩展性。 实验...

    贪吃蛇,c#语言,面向对象的程序设计

    这样可以减少代码重复,提高代码复用性。 总结来说,贪吃蛇游戏的C#实现不仅是一次实际编程的练习,更是深入理解和运用面向对象编程理念的好机会。通过这个项目,初学者能够熟悉C#的基本语法,掌握类和对象的创建,...

    C++面向对象程序设计语言ppt

    这有助于减少代码重复,提高代码复用性,使程序结构更加清晰。 2. **从C到C++**:C++是C语言的超集,它扩展了C语言的功能,引入了面向对象的概念。因此,熟悉C语言的程序员可以轻松过渡到C++,但需要注意C++中的...

Global site tag (gtag.js) - Google Analytics