[转帖]为什么Java中继承是有害的一

god

<B>概述</B>
/ X) f& {" v* C2 t9 o6 d7 [9 k
　　大多数好的设计者象躲避瘟疫一样来避免使用实现继承(extends 关系)。实际上80%的代码应该完全用interfaces写，而不是通过extends。“JAVA设计模式”一书详细阐述了怎样用接口继承代替实现继承。这篇文章描述设计者为什么会这么作。
7 v! M! V/ x1 _
　　Extends是有害的；也许对于Charles Manson这个级别的不是，但是足够糟糕的它应该在任何可能的时候被避开。“JAVA设计模式”一书花了很大的部分讨论用interface继承代替实现继承。

5 c7 D  u1 V! M! B1 |　　好的设计者在他的代码中，大部分用interface，而不是具体的基类。本文讨论为什么设计者会这样选择，并且也介绍一些基于interface的编程基础。
2 z2 l* N( v: Q- c1 `/ A4 v
<B>接口（Interface）和类（Class）</B>?
: F& a0 i! J& D+ U6 N
　　一次，我参加一个Java用户组的会议。在会议中，Jams Gosling（Java之父）做发起人讲话。在那令人难忘的Q&amp;A部分，有人问他：“如果你重新构造Java，你想改变什么？”。“我想抛弃classes”他回答。在笑声平息后，它解释说，真正的问题不是由于class本身，而是实现继承(extends 关系)。接口继承（implements关系）是更好的。你应该尽可能的避免实现继承。

<B>失去了灵活性</B>

　　为什么你应该避免实现继承呢？第一个问题是明确的使用具体类名将你固定到特定的实现，给底层的改变增加了不必要的困难。
, u# K" y5 a  G2 i
　　在当前的敏捷编程方法中，核心是并行的设计和开发的概念。在你详细设计程序前，你开始编程。这个技术不同于传统方法的形式----传统的方式是设计应该在编码开始前完成----但是许多成功的项目已经证明你能够更快速的开发高质量代码，相对于传统的按部就班的方法。但是在并行开发的核心是主张灵活性。你不得不以某一种方式写你的代码以至于最新发现的需求能够尽可能没有痛苦的合并到已有的代码中。

　　胜于实现你也许需要的特征，你只需实现你明确需要的特征，而且适度的对变化的包容。如果你没有这种灵活，并行的开发，那简直不可能。

　　对于Inteface的编程是灵活结构的核心。为了说明为什么，让我们看一下当使用它们的时候，会发生什么。考虑下面的代码：
8 |8 G0 f& T( W( K) f
<CCID_NOBR>
7 s4 {. K' L( y- ^7 f  K<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>
' a( K3 F. ?8 p# x
<TR>
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f()
" H, }# E) s' i7 K{   LinkedList list = new LinkedList();
    //...
    g( list );
}

" e- X+ A9 ~6 I1 X/ Eg( LinkedList list )
{
    list.add( ... );
    g2( list )
8 ^' v4 R. n4 i' j! p}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>
2 E) ]& A% m  m
4 p2 b& {" T- l" {- G8 k　　现在，假设一个对于快速查询的需求被提出，以至于这个LinkedList不能够解决。你需要用HashSet来代替它。在已有代码中，变化不能够局部化，因为你不仅仅需要修改f()也需要修改g()（它带有LinkedList参数），并且还有g()把列表传递给的任何代码。象下面这样重写代码:
, \" M2 S" p+ f' a0 X
2 G6 t: {2 Q- X7 N, S<CCID_NOBR>
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>

<TR>
/ [5 Y/ `: U1 ?8 j) ~<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f()
" L) ~9 {/ A% z8 g) w: s0 v3 Z{   Collection list = new LinkedList();
2 k; j+ i4 b: E" M2 {3 m* I: x% a    //...
    g( list );
}
/ m' g- ~$ P3 Y1 v2 d0 A# z
6 K; ^4 ^' a6 k! i4 a$ ]g( Collection list )
8 W4 {$ i2 r' `- O4 Y0 I{
+ ]) f6 O# Y9 r! z    list.add( ... );
. C2 P9 _' N5 D    g2( list )
}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>
4 x3 ^8 a/ H/ N, t/ U: z  ^
　　这样修改Linked list成hash，可能只是简单的用new HashSet()代替new LinkedList()。就这样。没有其他的需要修改的地方。

　　作为另一个例子，比较下面两段代码：

# l, k# R3 V  A6 U9 g( \<CCID_NOBR>
$ Y6 @6 ?* X- f3 p# j3 u" h6 X<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>
9 p# P3 Z+ F# p0 M  e
<TR>
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f()
{   Collection c = new HashSet();
    //...
1 A$ O: K. M' k. z    g( c );
}
* w" E" n  a& H$ W
7 f; }; z& Q: U& o2 M8 Rg( Collection c )
  @' q7 E8 p" f: r7 e2 r{
& y8 |* g) H/ P3 P7 d5 N    for( Iterator i = c.iterator(); i.hasNext() )
$ a* x$ o9 t7 T( _: m- N/ \2 d        do_something_with( i.next() );
4 H$ [: b# h! g& C9 F( C. o}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>

  H& R0 U& j- e8 r: Q& V: a; w和

<CCID_NOBR>
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>

& {8 r0 _: }( L' `) v<TR>
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f2()
{   Collection c = new HashSet();
. g- h. I- u* y4 b    //...
    g2( c.iterator() );
8 b% [4 `0 d2 ?}
& c7 x) x$ e) L6 ~9 l" W4 o1 [
0 b- L+ z4 r# y. Eg2( Iterator i )
{   while( i.hasNext() )
        do_something_with( i.next() );
}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>

　　g2()方法现在能够遍历Collection的派生，就像你能够从Map中得到的键值对。事实上，你能够写iterator，它产生数据，代替遍历一个Collection。你能够写iterator，它从测试的框架或者文件中得到信息。这会有巨大的灵活性。

<B>耦合</B>

　　对于实现继承，一个更加关键的问题是耦合---令人烦躁的依赖，就是那种程序的一部分对于另一部分的依赖。全局变量提供经典的例子，证明为什么强耦合会引起麻烦。例如，如果你改变全局变量的类型，那么所有用到这个变量的函数也许都被影响，所以所有这些代码都要被检查，变更和重新测试。而且，所有用到这个变量的函数通过这个变量相互耦合。也就是，如果一个变量值在难以使用的时候被改变，一个函数也许就不正确的影响了另一个函数的行为。这个问题显著的隐藏于多线程的程序。

　　作为一个设计者，你应该努力最小化耦合关系。你不能一并消除耦合，因为从一个类的对象到另一个类的对象的方法调用是一个松耦合的形式。你不可能有一个程序，它没有任何的耦合。然而，你能够通过遵守OO规则，最小化一定的耦合（最重要的是，一个对象的实现应该完全隐藏于使用他的对象）。例如，一个对象的实例变量（不是常量的成员域），应该总是private。我意思是某段时期的，无例外的，不断的。（你能够偶尔有效地使用protected方法，但是protected实例变量是可憎的事）同样的原因你应该不用get/set函数---他们对于是一个域公用只是使人感到过于复杂的方式（尽管返回修饰的对象而不是基本类型值的访问函数是在某些情况下是由原因的，那种情况下，返回的对象类是一个在设计时的关键抽象）。

　　这里，我不是书生气。在我自己的工作中，我发现一个直接的相互关系在我OO方法的严格之间，快速代码开发和容易的代码实现。无论什么时候我违反中心的OO原则，如实现隐藏，我结果重写那个代码（一般因为代码是不可调试的）。我没有时间重写代码，所以我遵循那些规则。我关心的完全实用—我对干净的原因没有兴趣。

<B>脆弱的基类问题</B>
( d7 F" n; M1 B1 G1 u: Z! O
3 P$ `! Y/ `+ @4 B& a+ ^' Y  F　　现在，让我们应用耦合的概念到继承。在一个用extends的继承实现系统中，派生类是非常紧密的和基类耦合，当且这种紧密的连接是不期望的。设计者已经应用了绰号“脆弱的基类问题”去描述这个行为。基础类被认为是脆弱的是，因为你在看起来安全的情况下修改基类，但是当从派生类继承时，新的行为也许引起派生类出现功能紊乱。你不能通过简单的在隔离下检查基类的方法来分辨基类的变化是安全的；而是你也必须看（和测试）所有派生类。而且，你必须检查所有的代码，它们也用在基类和派生类对象中，因为这个代码也许被新的行为所打破。一个对于基础类的简单变化可能导致整个程序不可操作。

8 q& X7 `- R$ |　　让我们一起检查脆弱的基类和基类耦合的问题。下面的类extends了Java的ArrayList类去使它像一个stack来运转：

<CCID_NOBR>
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>
8 Y2 k4 C; S; L  i# I2 w
<TR>
* f/ t! C0 n# X1 d( u6 v  u<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>class Stack extends ArrayList
{   private int stack_pointer = 0;

1 i3 z) i' }6 Z# }7 j9 _    public void push( Object article )
/ H' x$ p. N5 x0 v8 B) t% A    {   add( stack_pointer++, article );
: [6 ]. w6 h- v: ?4 B9 A    }
# c9 f2 l; C! e1 ~, ^1 A
" D0 v. E7 S! g4 _6 a8 B    public Object pop()
% l& ^) Z; g8 Y. W' }    {   return remove( --stack_pointer );
    }

    public void push_many( Object[] articles )
4 c, t7 R  H4 e5 V3 ^    {   for( int i = 0; i &lt; articles.length; ++i )
            push( articles );
, V: g$ y; `7 `" A4 g3 {    }
7 F* a/ k) l7 z}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>
/ g! Q9 w; R7 ~) q
甚至一个象这样简单的类也有问题。思考当一个用户平衡继承和用ArrayList的clear()方法去弹出堆栈时：

$ Y$ C  U) J' P<CCID_NOBR>
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>
  B! g3 s" r0 G9 b) r
<TR>
1 B. z4 h* @" s0 U1 G. V<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>Stack a_stack = new Stack();
a_stack.push("1");
a_stack.push("2");
; W" S0 l/ I" e8 _* p1 h3 B( ]a_stack.clear();</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>

　　这个代码成功编译，但是因为基类不知道关于stack指针堆栈的情况,这个stack对象当前在一个未定义的状态。下一个对于push（）调用把新的项放入索引2的位置。（stack_pointer的当前值），所以stack有效地有三个元素-下边两个是垃圾。（Java的stack类正是有这个问题，不要用它）.
2 M: Q3 e$ |' N/ ?3 w
　　对这个令人讨厌的继承的方法问题的解决办法是为Stack覆盖所有的ArrayList方法，那能够修改数组的状态，所以覆盖正确的操作Stack指针或者抛出一个例外。(removeRange()方法对于抛出一个例外一个好的候选方法)。

　　这个方法有两个缺点。第一，如果你覆盖了所有的东西，这个基类应该真正的是一个interface，而不是一个class。如果你不用任何继承方法，在实现继承中就没有这一点。第二，更重要的是，你不能够让一个stack支持所有的ArrayList方法。例如，令人烦恼的removeRange()没有什么作用。唯一实现无用方法的合理的途径是使它抛出一个例外，因为它应该永远不被调用。这个方法有效的把编译错误成为运行错误。不好的方法是，如果方法只是不被定义，编译器会输出一个方法未找到的错误。如果方法存在，但是抛出一个例外，你只有在程序真正的运行时，你才能够发现调用错误。

$ ~- `' h) i: {( B3 U) Q　　对于这个基类问题的一个更好的解决办法是封装数据结构代替用继承。这是新的和改进的Stack的版本：
$ ?7 t$ W* Y  y+ v% K  h  z( G
+ {8 J0 U+ n1 ~+ o  B/ z8 W<CCID_NOBR>
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>

<TR>
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>class Stack
{
    private int stack_pointer = 0;
    private ArrayList the_data = new ArrayList();
, W+ V# T' k% P; y0 p" w   
    public void push( Object article )
; L+ S" p3 I1 J2 R+ I0 D0 N' f{
' o' _- ]2 G$ T+ o  @6 v5 C    the_data.add( stack_poniter++, article );
% a2 c! X. p( l( q) j}

, t5 w0 D2 p7 k* `$ C) ]) g7 Npublic Object pop()
* b1 s' E) C4 D1 \! R/ h8 f2 u{
* R1 ~9 _" }" I" M    return the_data.remove( --stack_pointer );
}
) e( T2 R7 q8 Z
! T, Q2 [& B% L( @5 I/ V! ~public void push_many( Object[] articles )
+ B# M+ ]9 Y+ i0 o{
    for（ int i = 0; i &lt; o.length; ++i ）
( y' N" O' I! _6 t7 s        push( articles );
}
}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>
2 r" G8 q' h% w* s4 ?- @1 H: o
　　到现在为止，一直都不错，但是考虑脆弱的基类问题，我们说你想要在stack创建一个变量， 用它在一段周期内跟踪最大的堆栈尺寸。一个可能的实现也许象下面这样:
# w2 p  r" f( D
; w9 [# X9 y$ K- a: r<CCID_NOBR>
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>
2 X+ m2 S8 c! ^
0 U  H  J( N1 N<TR>
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>class Monitorable_stack extends Stack
{
    private int high_water_mark = 0;
- n' E# `) s( ?1 {    private int current_size;

  l+ s6 }& @, o& G" E    public void push( Object article )
5 a5 }% f3 \7 ]0 P# j    {
        if( ++current_size &gt; high_water_mark )
            high_water_mark = current_size;
        super.push( article );
# ^( }7 [$ b' F9 ~7 P# R    }

/ t' n' E8 d; ]( k2 N% m    publish Object pop()
) K7 v5 m4 }; w4 p# Q    {
! ^( z+ Q$ J6 F( E/ C3 {        --current_size;
( |& B7 z9 K; r$ w7 y( E# k# M# P        return super.pop();
    }
, S  Y  U7 c1 K
    public int maximum_size_so_far()
6 j0 [8 z" q2 y5 _2 L; R4 m    {
: ~; W; X: ?- D" P' E        return high_water_mark;
    }
}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>
# J0 @2 J$ g; Z% c9 M
　　这个新类运行的很好，至少是一段时间。不幸的是，这个代码发掘了一个事实，push_many()通过调用push()来运行。首先，这个细节看起来不是一个坏的选择。它简化了代码，并且你能够得到push()的派生类版本，甚至当Monitorable_stack通过Stack的参考来访问的时候，以至于high_water_mark能够正确的更新。