|
#
客户直接调用其server object（服务对象）的delegate class。
在server端（某个class）建立客户所需的所有函数，用以隐藏委托关系（delegation）。
先前（上个重构项）我从TelephoneNumber提炼出另一个class，现在我要将它inlining塞回到Person去。一开始这两个classes是分离的：
class Person...
public String getName() {
return _name;
}
public String getTelephoneNumber() {
return _officeTelephone.getTelephoneNumber();
}
TelephoneNumber getOfficeTelephone() {
return _officeTelephone;
}
private String _name;
private TelephoneNumber _officeTelephone = new TelephoneNumber();
class TelephoneNumber...
public String getTelephoneNumber() {
return ("(" + _areaCode + ")" + _number);
String getAreaCode() {
return _areaCode;
}
void setAreaCode(String arg) {
_areaCode = arg;
}
String getNumber() {
return _number;
}
void setNumber(String arg) {
_number = arg;
}
private String _number;
private String _areaCode;
首先我在Person中声明TelephoneNumber的所有[可见]（public）函数：
class Person...
String getAreaCode() {
return _officeTelephone.getAreaCode();
}
void setAreaCode(String arg) {
_officeTelephone.setAreaCode(arg);
}
String getNumber() {
return _officeTelephone.getNumber();
}
void setNumber(String arg) {
_officeTelephone.setNumber(arg);
}
现在，我要找出TelephoneNumber的所有用户，让它们转而使用Person接口。于是下列代码：
Person martin = new Person();
martin.getOfficeTelephone().setAreaCode("781");
就变成了：
Person martin = new Person();
martin.setAreaCode("781");
现在，我可以持续使用Move Method（142）和Move Field（146），直到TelephoneNumber不复存在。
作法（Mechanics)
- 在absorbing class（合并端的那个class）身上声明source class的public协议，并将其中所有函数委托（delegate）至source class。
- ==》如果[以一个独立接口表示source class函数]更合适的话，就应该在inlining之前先使用Extract Interface（341）。
- 修改所有source class引用点，改而引用absorbing class。
- ==》将source class声明为private，以斩断package之外的所有引用可能。
- 同时并修改source class的名称，这便可使编译器帮助你捕捉到所有对于source class的“dangling references”（虚悬引用点）。
- 编译，测试。
- 运用Move Method（142）和Move Field（146），将source class的特性全部搬移到absorbing class。
- 为source class举行一个简单的葬礼。
动机（Motivation）
Inline Class（154）正好与Extract Class（149）相反。如果一个class不再承担足够责任、不再有单独存在的理由（这通常是因为此前的重构动作移走了这个class的责任），我就会挑选这一[萎缩class]的最频繁用户（也是个class），以Inline Class（154）手法将[萎缩class]塞进去。
你的某个class没有做太多事情（没有承担足够责任）。
将class的所有特性搬移到另一个class中，然后移除原class。
让我们从一个简单的Person class开始：
class Person...
public String getName() {
return _name;
}
public String getTelephoneNumber() {
return ("(" + _officeAreaCode + ")" + _officeNumber);
}
String getOfficeAreaCode() {
return _officeAreaCode;
}
void setOfficeAreaCode(String arg) {
_officeAreaCode = arg;
}
String getOfficeNumber() {
return _officeNumber;
}
void setOfficeNumber(String arg) {
_officeNumber = arg;
}
private String _name;
private String _officeAreaCode;
private String _officeNumber;
在这个例子，我可以将[与电话号码相关]的行为分离到一个独立class中。首先我要定义一个TelephoneNumber class来表示[电话号码]这个概念：
class TelephoneNumber {
}
易如反掌！然后，我要建立从Person到TelephoneNumber的连接：
class Person...
private TelephoneNumber _officeTelephone = new TelephoneNumber();
现在，我运用Move Field（146）移动一个值域：
class TelephoneNumber {
String getAreaCode() {
return _areaCode;
}
void setAreaCode(String arg) {
_areaCode = arg;
}
private String _areaCode;
}
class Person...
public String getTelephoneNumber() {
return ("(" + getOfficeAreaCode() + ")" + _officeNumber);
}
String getOfficeAreaCode() {
return _officeTelephone.getAreaCode();
}
void setOfficeAreaCode(String arg) {
_officeTelephone.setAreaCode(arg);
}
然后我可以移动其他值域，并运用Move Method（142）将相关函数移动到TelephoneNumber class中：
class Person...
public String getName() {
return _name;
}
public String getTelephoneNumber() {
return _officeTelephone.getTelephoneNumber();
}
TelephoneNumber getOfficeTelephone() {
return _officeTelephone;
}
private String _name;
private TelephoneNumber _officeTelephone = new TelephoneNumber();
class TelephoneNumber...
public String getTelephoneNumber() {
return ("(" + _areaCode + ")" + _number);
String getAreaCode() {
return _areaCode;
}
void setAreaCode(String arg) {
_areaCode = arg;
}
String getNumber() {
return _number;
}
void setNumber(String arg) {
_number = arg;
}
private String _number;
private String _areaCode;
下一步要做的决定是：要不要对客户揭示这个新class？我可以将Person中[与电话号码相关]的函数委托（delegating）至
TelephoneNumber，从而完全隐藏这个新class；也可以直接将对用户曝光。我还可以将它暴露给部分用户（位于同一个package中的用
户），而不暴露给其他用户。
如果我选择暴露新class吗，我就需要考虑别名（aliasing）带来的危险。如果我暴露了TelephoneNumber，而有个用户修改了对象中的_areaCode值域值，我又怎么能知道呢？而且，做出修改的可能不是直接用户，而是用户的用户的用户。
面对这个问题，我有下列数种选择：
1.允许任何对象修改TelephoneNumber对象的任何部分。这就使得TelephoneNumber对象成为引用对象（reference object），对于我应该考虑使用Change Value to Reference（179）。这种情况下，Person应该是TelephoneNumber的访问点。
2.不许任何人[不通过Person对象就修改TelephoneNumber对象]。为了达到目的，我可以将TelephoneNumber设为不可修改的（immutable），或为它提供一个不可修改的接口（immutable interface）。
3.另一个办法是：先复制一个TelephoneNumber对象，然后将复制得到的新对象传递给用户。但这可能会造成一定程度的迷惑，因为人们会认为他们可以修改TelephoneNumber对象值。此外，如果同一个TelephoneNumber对象被传递给多个用户，也可能在用户之间造成别名（aliasing）问题。
Extract Class（149）是改善并发（concurrent）程序的一种常用技术，因为它使你可以提炼后的两个classes分别加锁（locks）。
作法（Mechanics)
- 决定如何分解class所负责任。
- 建立一个新class，用以表现从旧class中分离出来的责任。
- ==》如果旧class剩下的责任与旧class名称不符，为旧class易名。
- 建立[从旧class访问新class]的连接关系（link）。
- ==》也许你有可能需要一个双向连接。但是在真正需要它之前，不要建立[从新class同往旧class]的连接。
- 对于你想搬移的每一个值域，运用Move Field（146）搬移之。
- 每次搬移后，编译、测试。
- 使用Move Method（142）将必要函数搬移到新class。先搬移较低层函数（也就是[就其他函数调用]多于[调用其他函数]者），再搬移较高层函数。
- 每次搬移之后，编译、测试。
- 检查，精简每个class的接口。
- ==》如果你建立起双向连接，检查是否可以将它改为单向连接。
- 决定是否让新class暴光。如果你的的确需要暴光它，决定让它成为reference object（引用型对象）或immutable value object（不可变之[实值型对象]）。
动机（Motivation）
如果某些数据和某些函数总是一起出现，如果某些数据经常同时变化甚至彼此相依，这就表示你应该将它们分离出去。
另一个往往在开发后期出现的信号是class的[subtyped方式]。如果你发现subtyping只影响class的部分特性，或如果你发现某些特
性[需要以此方式subtyped]，某些特性[需要以彼此方式subtyped]，这就是意味你需要分解原来的class。
某个class做了应该由两个classes做的事。
建立一个新class，将相关的值域和函数从旧class搬移到新class。
如果有很多函数已经使用了_interestRate field,我应该先运用Self Encapsulate Field（171）：
class Account...
private AccountType _type;
private double _interestRate;
double interestForAmount_days(double amount, int days) {
return getInterestRate() * amount * days / 365;
}
private void setInterestRate(double arg) {
_interestRate = arg;
}
private double getInterestRate() {
return _interestRate;
}
这样，在搬移field之后，我就只需要修改访问函数就行了：
double interestForAmount_days(double amount, int days) {
return getInterestRate() * amount * days / 365;
}
private void setInterestRate(double arg) {
_type.setInterestRate(arg);
}
private double getInterestRate() {
return _type.getInterestRate();
}
如果以后有必要，我可以修改访问函数（accessors）的用户，让它们使用新对象。Self Encapsulate Field（171）使我得以保持小步前进。如果我需要对class做许多处理，保持小步前进是有帮助的。特别值得一提的是：首先使用Self Encapsulate Field（171）使我得以更轻松使用Move Method（142）将函数搬移到target class中。如果待移函数引用了field的访问函数（accessors），那么那些引用点是无须修改的。
|