% ~5 C$ s/ M/ X" N/ S X 为什么你应该避免实现继承呢?第一个问题是明确的使用具体类名将你固定到特定的实现,给底层的改变增加了不必要的困难。 2 j( L* c" F& O8 Y+ N
$ L6 W: }/ h) a( t1 b
在当前的敏捷编程方法中,核心是并行的设计和开发的概念。在你详细设计程序前,你开始编程。这个技术不同于传统方法的形式----传统的方式是设计应该在编码开始前完成----但是许多成功的项目已经证明你能够更快速的开发高质量代码,相对于传统的按部就班的方法。但是在并行开发的核心是主张灵活性。你不得不以某一种方式写你的代码以至于最新发现的需求能够尽可能没有痛苦的合并到已有的代码中。 5 h u) @; A2 g; u- @
7 d* X: B; } N% R* Y1 ^
胜于实现你也许需要的特征,你只需实现你明确需要的特征,而且适度的对变化的包容。如果你没有这种灵活,并行的开发,那简直不可能。 + p8 T, r ^8 R$ ?0 T) @- d7 M# o* s5 u
对于Inteface的编程是灵活结构的核心。为了说明为什么,让我们看一下当使用它们的时候,会发生什么。考虑下面的代码: r7 `0 D ]$ g; i/ A' b. D7 S " R+ s- F( j/ G9 k1 ]4 G# J* j<CCID_NOBR>. O: z( q$ N" N/ C3 T
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540> 4 D. V8 P# M" T " f2 W% Y2 [$ }7 ~9 S( q+ }; n<TR> # N/ T+ Y6 D9 e$ c! a8 w$ k<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f()0 K6 [# M5 i- X# D
{ LinkedList list = new LinkedList();& p- d$ e' z9 `3 h; k9 d
//...: I ?' u" q* S$ I; [
g( list ); 5 |; K1 _7 x; j d8 D- ]( f6 [' x} / |/ x- m+ T* Y: X( [+ C& d7 @5 U% l% ~
g( LinkedList list ) ( R; d& B, |" D+ J% k& o# ]" m{ * n+ Q. E D! a' t- d! h9 @9 j0 r list.add( ... ); _6 i) }7 K- G. O) i# ^
g2( list ) 0 D3 S/ S4 `# v% |! z}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>2 N7 T6 o5 }6 m2 j* L. t/ b1 [
4 S9 m1 |: Z7 _! o 现在,假设一个对于快速查询的需求被提出,以至于这个LinkedList不能够解决。你需要用HashSet来代替它。在已有代码中,变化不能够局部化,因为你不仅仅需要修改f()也需要修改g()(它带有LinkedList参数),并且还有g()把列表传递给的任何代码。象下面这样重写代码: 5 o3 ~- A4 o; g2 |1 N: t+ V3 P0 Q1 Z7 o2 m6 W& h+ G0 n
<CCID_NOBR>3 n% _1 H3 K0 [0 @( G5 k, ~ b
<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>3 r2 i* L- M3 Y# g r2 \
0 s: c. H0 ^) E3 K# R
<TR>8 O! ]* ^; S- \' S4 ^
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f() 9 a+ m6 x/ b% a3 k. Q! s% B{ Collection list = new LinkedList(); & [2 D& n* Y3 p6 h$ K //... 9 z3 d9 |/ A8 \4 E g( list );5 w, f# g" p* P8 p O9 N& \7 m1 }
} 7 c ~( M; N/ c1 x ( t2 I$ t* I* K c, G" ^4 o+ Cg( Collection list ) $ X& Q" x1 c9 m{ Q4 w7 b6 T8 `* S. L8 ?5 `- i0 K' Y list.add( ... );; {1 |5 Y& J, W3 u
g2( list ) 7 d) B( D2 R1 k( d! w}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>; W; R! ^8 x' A0 z) Z
. v" o2 C2 g3 r. K 这样修改Linked list成hash,可能只是简单的用new HashSet()代替new LinkedList()。就这样。没有其他的需要修改的地方。 * G) Q: N. v! f2 a, ^5 P3 k ) w" p' w* v2 \% O! P, @. z$ p0 f 作为另一个例子,比较下面两段代码: : y" e0 _/ q, E5 }% I B
$ b) e: _, F1 E) [3 n<CCID_NOBR> 5 h3 g; l8 x' v) J$ `$ e1 n# T7 N<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540> ; i2 R/ t l, M$ J8 w & N: P* R) u) d, |<TR> 2 ], E" w+ F2 l7 E; N* a* c<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f()# ~5 t" w# f% S, w: s
{ Collection c = new HashSet();4 K( F) X8 s; E
//... * R' Z6 l6 A& @1 U1 k, s8 P2 u3 l g( c ); 4 [5 s* l" @+ u0 ~+ y+ L}9 h9 x! y9 ]' f: ]; k2 U" o3 A
$ U A0 L: x+ i( E2 G- g$ }0 k
g( Collection c ) ) ~3 O! T& Q* l4 X3 _) P{9 G% K7 N5 z4 _+ V
for( Iterator i = c.iterator(); i.hasNext() )9 r. v" c; ?3 }8 F3 ?. }
do_something_with( i.next() ); , E% ]* i9 G! u; |$ g}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR> 3 m. G4 I7 ?0 j5 o# d+ M$ m; _. R- k7 ?! K/ w1 Q( g: p* T
和 # Y: _6 Y' j9 d/ T3 O& C3 z/ N* K2 I' X+ I: u
<CCID_NOBR> 9 }9 H* M6 R2 W1 g( H<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>6 D) J+ _7 b) }/ k, |0 L$ `
. T# k2 u- z- ]8 N<TR>4 g7 x1 Z4 T+ ` A. D
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>f2() 6 @/ P: Z7 c9 B/ X: O' L{ Collection c = new HashSet(); + l( e/ ?& `" D) v* m //... 3 x# z) q) ^" _+ Q2 v g2( c.iterator() ); 5 W$ k$ K4 s0 n; ?} 3 o$ e" |' j4 N/ A) \% y; Z1 w% r
g2( Iterator i ) " l5 g8 A& ]. s* h! n9 ^1 s{ while( i.hasNext() )) B, E# {: F* E
do_something_with( i.next() ); 0 S: E! K O: N/ F( a& ?8 Z6 ]}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>2 D, w) e y- `3 S* \$ M- {' c) `
A2 {4 \! ?# ~1 d6 R* P! T
g2()方法现在能够遍历Collection的派生,就像你能够从Map中得到的键值对。事实上,你能够写iterator,它产生数据,代替遍历一个Collection。你能够写iterator,它从测试的框架或者文件中得到信息。这会有巨大的灵活性。 ! s1 Y' L9 p% ^& I6 T
: F" h" B/ w0 m<B>耦合</B> * k2 y" @0 C+ h; O
2 o& v$ j2 P" Y; V) |2 [1 y 对于实现继承,一个更加关键的问题是耦合---令人烦躁的依赖,就是那种程序的一部分对于另一部分的依赖。全局变量提供经典的例子,证明为什么强耦合会引起麻烦。例如,如果你改变全局变量的类型,那么所有用到这个变量的函数也许都被影响,所以所有这些代码都要被检查,变更和重新测试。而且,所有用到这个变量的函数通过这个变量相互耦合。也就是,如果一个变量值在难以使用的时候被改变,一个函数也许就不正确的影响了另一个函数的行为。这个问题显著的隐藏于多线程的程序。 + ?/ v$ p5 e! \ ; x) p2 F; {/ x 作为一个设计者,你应该努力最小化耦合关系。你不能一并消除耦合,因为从一个类的对象到另一个类的对象的方法调用是一个松耦合的形式。你不可能有一个程序,它没有任何的耦合。然而,你能够通过遵守OO规则,最小化一定的耦合(最重要的是,一个对象的实现应该完全隐藏于使用他的对象)。例如,一个对象的实例变量(不是常量的成员域),应该总是private。我意思是某段时期的,无例外的,不断的。(你能够偶尔有效地使用protected方法,但是protected实例变量是可憎的事)同样的原因你应该不用get/set函数---他们对于是一个域公用只是使人感到过于复杂的方式(尽管返回修饰的对象而不是基本类型值的访问函数是在某些情况下是由原因的,那种情况下,返回的对象类是一个在设计时的关键抽象)。 ! G# u: ]' |: s8 m. d
- W6 m: c2 L" ? 这里,我不是书生气。在我自己的工作中,我发现一个直接的相互关系在我OO方法的严格之间,快速代码开发和容易的代码实现。无论什么时候我违反中心的OO原则,如实现隐藏,我结果重写那个代码(一般因为代码是不可调试的)。我没有时间重写代码,所以我遵循那些规则。我关心的完全实用—我对干净的原因没有兴趣。 : p5 V; q& y. G9 p ]8 S" ?+ ]8 i; c5 Z! r0 V<B>脆弱的基类问题</B> 6 E, j/ [1 W6 Q4 O$ b% f
! `) a$ V# W3 E* u0 Q( T
现在,让我们应用耦合的概念到继承。在一个用extends的继承实现系统中,派生类是非常紧密的和基类耦合,当且这种紧密的连接是不期望的。设计者已经应用了绰号“脆弱的基类问题”去描述这个行为。基础类被认为是脆弱的是,因为你在看起来安全的情况下修改基类,但是当从派生类继承时,新的行为也许引起派生类出现功能紊乱。你不能通过简单的在隔离下检查基类的方法来分辨基类的变化是安全的;而是你也必须看(和测试)所有派生类。而且,你必须检查所有的代码,它们也用在基类和派生类对象中,因为这个代码也许被新的行为所打破。一个对于基础类的简单变化可能导致整个程序不可操作。 0 e) M+ k' z' m' M4 @6 u + K+ z! s: I" X- N+ _2 A8 m 让我们一起检查脆弱的基类和基类耦合的问题。下面的类extends了Java的ArrayList类去使它像一个stack来运转: 8 o& g! H' r* }! z+ \; h. y) M2 W& O$ ]
; R+ |' L, N' H+ P<CCID_NOBR> 2 v. M! g& w" I6 I6 @# F<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>0 o; o* l) B. _6 }
% {7 k3 z/ `) o<TR>1 }1 _, o2 d4 ^5 B- p! i4 \& W f9 Z
<TD bgColor=#e6e6e6 class=code><RE><CCID_CODE>class Stack extends ArrayList . a3 t p$ m* O0 i{ private int stack_pointer = 0; 7 ?$ {% j: c0 c6 A7 W4 M6 i 4 [* I7 o& Q$ [+ }. S, E { public void push( Object article ) / L. ~% m7 D3 j { add( stack_pointer++, article );0 i' X- d/ b4 Y: I) \9 n0 A
}& f: [. w; v* ]; H% L
( H1 W* W4 @ r9 w5 ]( \ public Object pop() 8 V: t- a3 r& l5 b { return remove( --stack_pointer );3 ?, l6 l5 {+ u. ?4 e3 H; N
}: k( U( \. b7 X2 w2 R* k
/ T0 d+ O# T+ q( n
public void push_many( Object[] articles )2 J* w1 C( N6 @0 r4 S
{ for( int i = 0; i < articles.length; ++i ) # w8 ~9 q+ w$ M, V1 Z+ @ push( articles );7 i- J9 ]' f! v O6 @
}/ O; g% ]+ i! V2 L
}</CCID_CODE></PRE></TD></TR></TABLE></CCID_NOBR>: K C0 u/ Z; c9 K
+ }9 F9 h! t( }2 _' \# g9 k甚至一个象这样简单的类也有问题。思考当一个用户平衡继承和用ArrayList的clear()方法去弹出堆栈时: 6 o+ E. n2 T$ i% L, M
1 o! S* M. d7 U/ d# P2 a" E9 {0 R
<CCID_NOBR> & J5 S; A c. O3 c& L5 C<TABLE align=center border=1 borderColorDark=#ffffff borderColorLight=black cellPadding=2 cellSpacing=0 width=540>; j+ ?/ y/ h }