《重构-改善既有代码的设计》系列读书笔记（三、类的重构）

发表于   |  

在对象之间搬移特性

在对象的设计过程中，决定把责任放在哪里，即使不是最重要的事情，也是最重要的使用之一，虽然不能一开始就完全设计正确，但是我们可以使用重构去完善自己的设计

Move Method(搬移函数)

你的程序中，有个函数与其所在类之外的其他类进行更多的交流，调用后者，或者被后者调用

动机
  • 如果一个类有太多行为，就会承担过多的责任，请为这个类减负
  • 如果一个类与另一个类有太多合作，会形成高度的耦合
  • 如果一个函数使用外部类的次数比使用所在类的次数还多，则应该被移出所在类
做法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// before
class Account...
	double overdraftCharge() {
		if (_type.isPremium() ){
			double result = 10;
			if (_daysOverdrawn > 7) result += (_daysOverdrawn - 7) * 0.85;
			return result;
		}
		else {
			return _daysOverdrawn * 1.75
		}
	}
	double bankCharge() {
		double result = 4.5;
		if (_daysOverdrawn > 0) result += overdraftCharge();
		return result;
	}
	
	private AccountType _type;
	private int _daysOverdrawn;
// after
class AccountType...
	double overdraftCharge(Account account) {
		if (isPremium()) {
			double result = 10;
			if (account.getDaysOverdrawn() - 7) {
				result += (account.getDaysOverdrawn() - 7) * 0.85;
			}
			else {
				return result;
			}
		}
		else {
			return account.getDaysOverdrawn() * 1.75;
		}
	}
	
class Account...
		double bankCharge() {
		double result = 4.5;
		if (_daysOverdrawn > 0) 
			result += _type.overdraftCharge(self);
		return result;
	}
	
	private AccountType _type;
	private int _daysOverdrawn;

Move Field(搬移字段)

某个字段被其所在类之外的另一个类更多的用到，搬移它到正确的地方。

动机
做法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// before
class Account...
	private AccountType _type;
	private double _interestRate;//搬移到AccountType
	double interestForAmount_days (double amount,int days) {
		return _interestRate * amount * days / 365;
	}
//after
class AccountType...
	private double _interestRate;
	
	void setInterestRate (double arg) {
		_interestRate = arg
	}
	
	double getInterestRate () {
		return _interestRate;
	}
	
class Account...	
	private AccountType _type;
	double interestForAmount_days (double amount,int days) {
		return getInterestRate() * amount * days / 365;
	}
	
	private void setInterestRate(double arg){
		_type.setInteresetRate(arg);
	}
	
	private double getInterestRate() {
		return _type.getInteresetRate();
	}

Extract Class (提炼类)

某个类做了应该由两个类做的事。

动机
  • 一个类应该是一个清楚的抽象，处理一些明确的责任。
  • 类的不断迭代，会导致体积不断增大，责任越来越多。
  • 如果某些数据和函数总是一起出现，某些数据经常同时变化甚至彼此依赖，这就表示你应该将它们分离出去
  • 如果一个类在子类化时出现分歧，则该类可能需要被分解。
做法
  • 新建类，将需要分离的代码拷贝过来。
  • 建立从旧类访问新类的连接关系。
  • 使用上面的Move Method 和 Move Field方法对新类进行重构。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// before
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;
	
//after
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 ("(" + _officeAreaCode + ")" + _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;

Inline Class (将类内联化)

某个类没有做太多事

动机
  • 如果一个类不再承担足够的责任，不再有单独存在的理由，将它内联到另一个类中
做法
  • Extract Class的逆过程

Hide Delegate(隐藏委托关系)

客户通过一个委托类来调用另外一个对象

动机
  • 封装意味着每个对象应该尽量少的了解系统的其他部分，如果发生变化，需要了解这个变化的对象就会很少，这会使变化更容易
  • 针对上面的例子，如果委托关系发生变化，客户也得相应变化。
做法
  • 在委托类中加一个代理方法，将获取对象的逻辑留在这个类中，不要暴露给客户
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// before
class Person...
	Department _department;
	
	public Department getDepartment() {
		return _department;
	}
	public void setDepartment(Department arg) {
		_department = arg;
	}
class Department {
	private String _chargeCode;
	private String _manager;
	public Department(Person manager) {
		_manager = manager;
	}
	
	public Person getManager() {
		return _manager;
	}
}
//after
class Person...	
	Department _department;
	
	public void setDepartment(Department arg) {
		_department = arg;
	}
	//新加一个代理方法
	public Person getManager() {
		return _department.getManager();
	}
class Department {
	private String _chargeCode;
	private String _manager;
	public Department(Person manager) {
		_manager = manager;
	}
	
	public Person getManager() {
		return _manager;
	}
}

Remove Middle Man (移除中间人)

某个类做了过多的简单协议

动机
  • 如果某个类的代理方法越来越多，变成了一个完全的中间人，此时你应该让客户直接调用委托对象本身
  • Hide Delegate 和 Remove Middle Man是一对可逆的过程，代码总是在变化的，之前的修改可能在之后变得并不适用，不用说对不起，继续把这个问题修补好就行了。
做法
  • 和Hide Delegate过程刚好相反
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//before
class Person...	
	Department _department;
	public void setDepartment(Department arg) {
		_department = arg;
	}
	public Person getManager() {
		return _department.getManager();
	}
//after
class Person...	
	Department _department;
	
	public Department getDepartment() {
		return _department;
	}
	public void setDepartment(Department arg) {
		_department = arg;
	}

Introduce Foreign Method(引用外加函数)

你需要为提供服务的类增加一个函数，但是你无法修改这个类

动机
  • 需要为不能修改源代码的类增加函数
  • 如果这个函数只使用一次，可能没有必要，如果需要多次使用，则应该这么做。
做法
1
2
3
4
5
6
7
8
9
//before
Date newStart = new Date (previousEnd.getYear(),previousEnd.getMonth(),previousEnd.getDay() + 1);
//after
Date newStart = nextDay(previousEnd);
private static Date nextDay(Date arg){
	return new Date(previousEnd.getYear(),previousEnd.getMonth(),previousEnd.getDay() + 1);
}

Introduce Local Extension(引入本地扩展)

你需要为服务类提供一些额外函数，但是你无法修改这个类。

动机
  • 如果需要加多个函数，则应该对这些函数做一个封装，而不是散落在各处
  • 子类是更好的扩展方式