|
#
范例（Examples）
class IntRange {
private int _low, _high;
boolean includes(int arg) {
return arg >= _low && arg <= _high;
}
void grow(int factor) {
_high = _high * factor;
}
IntRange(int low, int high) {
_low = low;
_high = high;
}
为了封装_low和_high这两个值域，我先定义[取值/设值函数]（如果此前没有定义的话），并使用它们：
class IntRange {
private int _low, _high;
boolean includes(int arg) {
return arg >= _low && arg <= _high;
}
void grow(int factor) {
_high = _high * factor;
}
int getLow() {
return _low;
}
int getHigh() {
return _high;
}
void setLow(int arg) {
_low = arg;
}
void setHigh(int arg) {
_high = arg;
}
使用本项重构时，一般说来，设值函数被认为应该在[对象创建后]才使用，所以初始化过程中的行为有可能与设值函数的行为不同。这种情况下，我也许在构造函数中直接访问值域，要不就是建立另一个独立的初始化函数：
IntRange(int low, int high) {
initialize(low, high);
}
private void initialize(int low, int high) {
_low = low;
_high = high;
}
一旦你拥有一个subclass，上述所有动作的价值就体现出来了。如下所示：
class CappedRange extends IntRange {
CappedRange(int low, int high, int cap) {
super(low, high);
_cap = cap;
}
private int _cap;
int getCap() {
return _cap;
}
int getHigh() {
return Math.min(super.getHigh(), getCap());
}
}
现在，我可以CappedRange class中覆写getHigh（），从而加入对cap的考虑，而不必修改IntRange class的任何行为。
作法（Mechanics)
- 为[待封装值域]建立取值/设值函数（getting/setting methods）。
- 找出该值域的所有引用点，将它们全部替换为[对于取值/设值函数的调用]。
- ==》如果引用点是[读值]值域值，就将它替换为[调用取值函数]；如果引用点是[设定]值域值，就将它替换为[调用设值函数]。
- ==》你可以暂时为设值域改名，让编译器帮助你查找引用点。
- 将该值域声明为private。
- 复查，确保找出所有引用点。
- 编译，测试。
动机（Motivation）
如果你想访问superclass中的一个值域，却又想在subclass中将[对这个变量的访问]改为一个计算后的值，这就是最该使用Self Encapsulate Field（171）的时候。[值域自我封装]只是第一步。完成自我封装之后，你可以在subclass中根据自己的需要随意覆写取值/设值函数（getting/setting methods）。
你直接访问一个值域（field），但与值域之间的耦合关系逐渐变得笨拙。
为这个值域建立取值/设值函数（getting/setting methods），并且只以这些函数来访问值域。
private int _low, _high;
boolean includes(int arg) {
return arg >= _low && arg <= _high;
}
private int _low, _high;
boolean includes(int arg) {
return arg >= getLow() && arg <= getHigh();
}
int getLow() {return _low;}
int getHigh() {return _high;}
首先声明一个wrapping class：
class MfDateWrap {
private Date _original;
}
使用wrapping方案时，我对构造函数的设定与先前有所不同。现在的构造函数将只是执行一个单纯的委托动作（delegation）：
public MfDateWrap(String dateString) {
_original = new Date(dateString);
}
而转型构造函数则只是对其instance变量赋值而已：
public int getYear() {
return _original.getYear();
}
public boolean equals(MfDateWrap arg) {
return (toDate().equals(arg.toDate());
}
完成这项工作之后，我就可以后使用Move Method（142）将日期相关行为搬移到新class中。于是以下代码：
client class...
private static Date nextDay(Date arg) {
return new Date(arg.getYear(), arg.getMonth(), arg.getDate() + 1);
}
经过搬移之后，就成了：
class MfDate...
Date nextDay() {
return new Date(getYear(), getMonth(), getDate() + 1);
}
首先，我要建立一个新的MfDateSub class来表示[日期]，并使其成为Date的subclass：
class MfDateSub extends Date
然后，我需要处理Date和我的extension class之间的不同处。MfDateSub构造函数需要委托（delegating）给Date构造函数：
public MfDateSub(String dateString) {
super(dateString);
}
现在，我需要加入一个转型构造函数，其参数是一个隶属原类的对象：
public MfDateSub（Date arg）{
super（arg.getTime());
}
现在，我可以在extension class中添加新特性，并使用Move Method（142）将所有外加函数（foreign method）搬移到extension class。于是，下面的代码：
client class...
private static Date nextDay(Date arg) {
return new Date(arg.getYear(), arg.getMonth(), arg.getDate() + 1);
}
经过搬移之后，就成了：
class MfDate...
Date nextDay() {
return new Date(getYear(), getMonth(), getDate() + 1);
}
我将以Java1.0.1的Date class为例。Java 1.1已经提供了我想要的功能，但是在它到来之前的那段日子，很多时候需要扩展Java 1.0.1的Date class。
第一件待决事项是使用subclass或wrapper。subclassing是比较显而易见的办法：
class mfDate extends Date {
public nextDay() ...
public dayOfYear() ...
}
wrapper则需要上委托（delegation）：
class mfDate {
private Date _original;
作法（Mechanics)
- 建立一个extension class，将它作为原物（原类）的subclass或wrapper。
- 在extension class中加入转型构造函数（converting constructors）。
- ==》所谓[转型构造函数]是指接受原物（original）作为参数。如果你采用subclassing方安，那么转型构造函
数应该调用适当的superclass构造函数；如果你采用wrapper方案，那么转型构造函数应该将它所获得之引数（arument）赋值给[用以保
存委托关系（delegate）]的那个值域。
- 在extension class中加入新特性。
- 根据需要，将原物（original）替换为扩展物（extension）。
- 将[针对原始类（original class）而定义的所有外加函数（foreign methods）]搬移到扩展类（extension）中。
动机（Motivation）
如果你需要的额外函数超过两个，外加函数（foreign
methods）就很难控制住它们了。所以，你需要将这些函数组织在一起，放到一个恰当地方去。要达到这一目的，标准对象技术subclassing和
wrapping是显而易见的办法。这种情况下我把subclass或wrapper称为local extension（本地扩展）。
在subclass和wrapper之间做选择时，我通常首先subclass。
你所使用的server class需要一些额外函数，但你无法修改这个class。
建立一个新class，使它包含这些额外函数。让这个扩展品成为source class的subclass（子类）或wrapper（外覆类）。
|