《重构--改善既有代码的设计》--处理概括关系(11)

一、Pull Up Field（字段上移）

两个子类拥有相同的字段。将该字段移至超类。



二、Pull Up Method（函数上移）

有些函数，在各个子类中产生完全相同的结果。将该函数移至父类。



1、检查待提升函数，确定它们是完全一致的。

2、如果特提升函数名不同，修改与父类相同的函数名。

3、在父类新建一个函数，将待提升的函数代码复制到到新函数中。

4、编译。

5、移除子类中的函数。

6、编译、测试。

7、逐一移除子类中的函数，直到只剩下父类中的函数。

8、编译、测试。



重构后：



三、Pull Up Constructor Body（构造函数本体上移）

你在各个子类中拥有一些构造函数，它们的本体几乎完全一致。在父类中新建一个构造函数，并在子类构造函数中调用它。

1、在父类定义一个构造函数。

2、将子类共同代码搬移到父类中构造函数中。

3、将子类构造函数共同代码删除，改用父类中的构造函数。

4、编译、测试。

class Employee
{
protected string _name;
protected string _id;

public Employee(string name, string id)
{
_name = name;
_id = id;
}
}

class Manager : Employee
{
private int _grade;
public Manager(string name, string id, int grade)
{
_name = name;
_id = id;
_grade = grade;
}
}

重构后：

class Manager : Employee
{
private int _grade;
public Manager(string name, string id, int grade)
:base(name,id)
{
_grade = grade;
}
}

四、Push Down Method（函数下移）

父类中的某个函数只与部分（而非全部）子类有关。将这个函数移到相关的那些子类去。



五、Push Down Field（字段下移）

父类中某个字段只被部分（而非全部）子类用到。将这个字段移到需要它的那些子类中。



六、Extract Subclass（提炼子类）

类中的某些特性只被某些（而非全部）实例用到。新建一个子类，将上面所说的那一部分特性移到子类中。



1、为源类定义一个新的子类。

2、为这个新的子类提供构造函数。

3、找出父类的构造函数，如果是需要子类的构造函数，请替换之。

4、逐一使用Push Down Method和Push Down Field将源类的特性移到子类。

5、编译、测试。

class JobItem
{
private int _unitPrice;
private int _quantity;
private bool _isLabor;
private Employee _employee;

public JobItem(int unitPrice, int quantity, bool isLabor, Employee employee)
{
_unitPrice = unitPrice;
_quantity = quantity;
_isLabor = isLabor;
_employee = employee;
}

public int GetTotalPrice()
{
return GetUnitPrice() * _quantity;
}

public int GetUnitPrice()
{
return (_isLabor) ?
_employee.GetRate() : _unitPrice;
}

public int Quantity
{
get { return _quantity; }
}

public Employee Employee
{
get { return _employee; }
}
}

class Employee
{
protected int _rate;

public Employee(int rate)
{
_rate = rate;
}

public int GetRate()
{
return _rate;
}
}

class Program
{
static void Main(string[] args)
{
Employee kent = new Employee(3600);
JobItem j1 = new JobItem(0, 5, true, kent);
}
}

创建一个子类，重构后：

class JobItem
{
private int _unitPrice;
private int _quantity;
private bool _isLabor;
protected Employee _employee;

protected JobItem(int unitPrice, int quantity, bool isLabor)
{
_unitPrice = unitPrice;
_quantity = quantity;
_isLabor = isLabor;
}

public JobItem(int unitPrice, int quantity)
: this(unitPrice, quantity, false)
{
}

public int GetTotalPrice()
{
return GetUnitPrice() * _quantity;
}

public virtual int GetUnitPrice()
{
return _unitPrice;
}

public int Quantity
{
get { return _quantity; }
}

protected virtual bool IsLabor()
{
return false;
}
}

class LaborItem:JobItem
{
public LaborItem(int unitPrice, int quantity, bool isLabor)
: base(unitPrice, quantity, isLabor)
{
}

public LaborItem(int quantity, Employee employee)
: base(0, quantity, true)
{
_employee = employee;
}

public Employee Employee
{
get { return _employee; }
}

protected override bool IsLabor()
{
return true;
}

public override int GetUnitPrice()
{
return _employee.GetRate();
}
}

客户端：

class Program
{
static void Main(string[] args)
{
Employee kent = new Employee(3600);
JobItem j1 = new LaborItem(10, 5, true);
JobItem j2 = new JobItem(10, 15);
}
}

七、Extract Superclass（提炼超类）

两个类有相似特性。为这两个类建立一个父类，将相同特性移至父类。



1、建立一个抽象父类。

2、运用Pull Up Field,Pull Up Method,Pull Up Constructor Boday逐一将子类共同元素上移到父类。

3、编译、测试。

八、Extract Interface（提炼接口）

若干客户使用类接口中的同一子集，或者两个类的接口有部分相同。将相同的子集提炼到一个独立接口中。



1、新建一个接口。

2、在接口中声明待提炼类的共通操作。

3、让相关的类实现其接口。

4、调整客户端的类型声明，令其使用该接口。

class Employee
{
private int _rate;
private bool _isSpecialSkill;

Employee(int rate, bool isSpecialSkill)
{
_rate = rate;
_isSpecialSkill = isSpecialSkill;
}

public int GetRate()
{
return _rate;
}

public bool HasSpecialSkill()
{
return _isSpecialSkill;
}
}

class TimeSheet
{
double Charge(Employee employee, int days)
{
int basic = employee.GetRate() * days;
return (employee.HasSpecialSkill()) ? (basic * 1.05) : basic;
}
}

重构后：

interface IBillable
{
int GetRate();
bool HasSpecialSkill();
}

class TimeSheet
{
double Charge(<span style="color:#ff0000;">IBillable </span>employee, int days)
{
int basic = employee.GetRate() * days;
return (employee.HasSpecialSkill()) ? (basic * 1.05) : basic;
}
}

九、Collapse Hierarchy（折叠继承体系）

父类与子类之间无太大区别，将它们合为一体。



1、选择你想移除的类：父类或子类。

2、使用Pull Up Field,Pull Up Method或Push Dwon Field,Push Down Method，把想移除的行为和属性搬移到另一个类中。

3、编译、测试。

4、调整原类的引用点，改为新类的引用。

5、移除源空类。

6、编译、测试。

十、Form Template Method（塑造模板函数）

你有一些子类，其中相应的函数以相同的顺序执行类的操作，但各个操作的细节上有所不同。将这些操作分别放进独立函数中，并保持它们都有相同的签名，于是原函数也就变得相同了。然后将原函数上移至父类。



1、在各个子类中分解目标函数，使分解后的各个函数不完全相同。

2、运用Pull Up Method将各个子类完全相同的函数上移父类。

3、对于那些完全不同的函数，实施Rename Method，使这些函数的签名完全相同。

4、编译、测试。

5、运用Pull Up Method将所有函数逐一上移到父类，并声明为抽象函数。

6、编译、测试。

7、移除子类中的原函数，编译、测试。

重构后：



十一、Replace Inheritance with Delegation（以委托取代继承）

某个子类只使用父类接口中的一部分，或是根本不需要继承而来的数据。在子类中新建一个字段用以保存父类，调整子类函数，令它改而委托父类，然后去掉两者之间的继承关系。



1、在子类型新建一个字段，引用父类的一个实例。

2、修改子类所有函数，让它们不使用父类，转而使用字段。

3、编译、测试。

4、去除继承关系。

5、编译、测试。

十二、Replace Delegation with Inheritance（以继承取代委托）

你在两个类之间使用委托关系，并经常为整个接口编写许多极简单的委托函数。让委托类继承受托类。



1、让委托端成为受托端的子类。

2、编译。

3、将受托字段设为该字段所处对象本身。

4、去掉简单的委托函数。

5、编译、测试。

6、把调用委托的代码改为对象本身。

7、移除受托字段。

class Person
{
private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}

public string GetLastName()
{
return _name.SubString(_name.LastIndexOf(' ') +1);
}
}

class Employee
{
Person _person = new Person();

public override string ToString()
{
return "Emp:" + _person.GetLastName();
}
}

重构后：

class Employee : Person
{
public override string ToString()
{
return "Emp:" + GetLastName();
}
}