1. 前言
之前的重构系列中,介绍了书中提到的重构基础,以及识别代码的坏味道。今天继续第三更,讲述那些重构手法(上)。看看哪些手法对你的项目能有所帮助…
2. 重新组织函数
对函数进行整理,使之更恰当的包装代码。
1、Extract Method 提炼函数。
改造前:
void printInfoAndDetail() { this.printInfo(); System.out.println("this is detail name:" + _name); System.out.println("this is detail account:" + _account);}
改造后:
void printInfoAndDetail() { this.printInfo(); this.printDetail();}void printDetail() { System.out.println("this is detail name:" + _name); System.out.println("this is detail account:" + _account);}
动机:
控制函数的粒度,函数粒度很小,那么被复用的机会就更大;其次会使高层函数读起来就像一系列注释,再次,如果函数都是细粒度,那么函数的覆盖也会更容易。
一个函数多长才算合适?其实长度不是关键问题,关键在于函数名和函数本体之间的语义距离。
做法:
1、创造一个新函数,根据这个函数意图来命名(以它”做什么“来命名,而不是”怎样做“命名)。
只要新的函数名能够以更好的方式昭示代码意图,你也应该提炼他(就算代码只是一条消息,或一个函数调用)。但如果你想不出一个更有意义的名称,就别动。
2、将提炼出来额代码从源函数复制到新建的目标函数中。
3、检查变量。检查提炼出的代码是否引用了源代函数的局部变量或参数。以被提炼函数中是否含有临时变量。
难点:
这个重构手法的难点就在于局部变量的控制,包括传进源函数的参数和源函数所有声明的临时变量。
2、Inline Method 内联函数。
改造前:
int getRating() { return isGe5() ? 2 : 1;}boolean isGe5(){ return _num >= 5; }
改造后:
int getRating() { return _num >= 5 ? 2 : 1;}
动机:
移除非必要的间接层。当然间接层有其价值,但不是所有的间接层都有价值,可以去除那些无用的间接层。
做法:
1、检查函数,确定他不具备多态性。如果有子类继承了这个函数,那就不能将此函数内联。因为子类无法覆盖一个根本不存在的函数。如例子中,子类可以重写isGe5(),但内敛之后的_num > 5 ? 2 : 1是无法重写的,除非你重写了getRating()。
2、找出函数的所有被调用点,将这个函数的所有被调用点都替换为函数本体。
3、Inline Temp 内联临时变量。
改造前:
double price = order.price();return price > 1000;
改造后:
return order.price() > 1000
4、Replace Temp With Query 以查询取代临时变量。
改造前:
double price = _qu * _item;if(price > 1000){ return price * 0.95;} else { return price * 0.98; }
改造后:
if(getPrice() > 1000){ return getPrice() * 0.95;} else { return getPrice() * 0.98; }double getPrice(){ return _qu * _item;}
5、Introduce Explaining Variable 引入解释性变量。
改造前:
if((platform.indexOf("mac") > -1) && (platform.indexOf("ie") > -1) && resize > 0){ // todo... }
改造后:
final boolean isMac = (platform.indexOf("mac") > -1;final boolean isIe = (platform.indexOf("ie") > -1;final boolean resized = resize > 0;if( && isIe && resized){ // todo... }
6、Split Temporary Variable 分解临时变量。
改造前:
double temp = 2 * (_h + _w);System.out.println(temp);temp = _h * _w;System.out.println(temp);
改造后:
final double temp = 2 * (_h + _w);System.out.println(temp);final double area = _h * _w;System.out.println(area);
7、Remove Assignments to Parameters 移除对参数的赋值。
改造前:
int discount(int inputVal) { if(inputVal > 50) inputVal -= 2;}
改造后:
int discount(int inputVal) { int result = inputVal; if(inputVal > 50) result -= 2;}
3. 在对象之间搬移特性
“决定把责任放在哪儿”。
1、Move Method 搬移函数。
如果一个类有太多的行为,或如果一个类于另一个类有太多合作而形成高度耦合,尝试搬移函数。将旧函数变成一个单纯的委托函数,或是将旧函数完全移除。
改造前:
class Account { private AccountType _type; private int _dayOverdrawn; double overdraftCharge(){ if(_type.isPremium()) { double result = 10; if(_dayOverdrawn > 7) result += (_dayOverdrawn - 7) * 0.85; return result; } else { return _dayOverdrawn * 1.75; } }}
改造后:
class Account { private AccountType _type; private int _dayOverdrawn; double overdraftCharge(){ return _type.overdraftCharge(_dayOverdrawn); }}class AccountType { double overdraftCharge(int daysOverdrawn){ if(isPremium()) { double result = 10; if(dayOverdrawn > 7) result += (dayOverdrawn - 7) * 0.85; return result; } else { return dayOverdrawn * 1.75; } }}
2、Move Field 搬移字段。
如果一个字段,在其所驻类之外的另一个类中有更多函数使用了它,就要考虑搬移这个字段。这里的使用可能是设值,取值函数间接进行的。
改造前:
class Account { private AccountType _type; private int _rate; double overdraftCharge(double amount, int days){ return _rate * amount * days / 365; }}
改造后:
class Account { private AccountType _type; double overdraftCharge(){ return _type.getRate() * amount * days / 365; }}class AccountType { private double _rate; void setRate(double r) { this._rate = r; } void getRate() { return _rate; }}
3、Extract Class 提炼类。
建立一个新类,将相关的字段和函数从旧类搬移到新类。一个类应该是一个清楚的抽象,处理一些明确的责任。
改造前:
class Account { private String personName; private String personPhone; private double money; public String getAccountInfo(){ return personName + ",联系方式:" + personPhone + ",余额:" + money; } }
改造后:
class Account { private Person person = new Person(); private double money; public String getAccountInfo(){ return person.getPersonName() + person.personPhone() + ",余额:" + money; } }class Person { private String personName; private String personPhone; public String getPersonName(){ return "联系人:" + personName; } public String getPersonPhone(){ return "联系方式:" + personPhone; }}
4、Inline Class 将类内联化。
将这个类的所有特性搬移到另一个类中,然后移除原类。与Extract Class相反。
5、Hide Delegate 隐藏“委托关系”。
“封装”即使不是对象的最关键特性,也是最关键特性之一。“封装”意味着每个对象都应该尽可能少了解系统的其他部分。
改造前:
class Person { private Department department; public Department getDepartment(){ return department; } }class Department { private Person manager; public Person getManager(){ return manager; }}// 如果客户希望知道某人的经理是谁,那他的调用关系是:xxx.getDepartment().getManager();// 暴露了部门和经理的委托关系
改造后:
class Person { private Department department; public Department getDepartment(){ return department; } public Person getManager(){ return department.getManager(); } }class Department { private Person manager; public Person getManager(){ return manager; }}// 如果客户希望知道某人的经理是谁,那他的调用关系是:(隐藏了Department)xxx.getManager();
6、Remove Middle Man 移除中间人。
某个类做了过多的简单委托动作。
7、Introduce Foreign Method 引入外加函数。
当你需要为提供服务的类增加一个函数,但你无法修改这个类。如果你只使用这个函数一次,那么额外编码工作没什么大不了,升值可能根本不需要原本提供服务的那个类。然而,如果你需要多次使用这个函数,就得不断重复这些代码。重复代码是软件万恶之源。
改造前:
Date newStart = new Date(pre.getYear(), pre.getMethod(), pre.getDate() + 1);
改造后:
Date newStart = nextDay(pre);private static Date nextDay(Date arg) { return new Date(arg.getYear(), arg.getMethod(), arg.getDate() + 1);}
如真实项目中的案例:
BeanUtil.copyProperties(),原始方法该行为需要抛异常,且被建议不再使用该方法进行bean复制。
于是引入外加函数:
class BeanUtilExt { public static void copyProperties(Object target, Object source) { try { BeanUtil.copyProperties() } catch (Exception) { // ignored... } }}
这种方式个人不推荐。
8、Introduce Local Extension 引入本地扩展。
当你需要为提供服务的类提供一些额外函数,但你无法修改这个类。
4. 重新组织数据
1、Self Encapsulate Field 自封装字段。
改造前:
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;}
直接访问变量好处:代码容易阅读。
间接访问变量好处:子类可以通过重写(覆盖)一个函数而改变获取数据的途径。
2、Replace Data Value with Object 以对象取代数据值。
开发初期,你往往决定以简单的数据项表示简单的情况。但是,随着开发的进行,你可能会发现,这些简单的数据项不再那么简单了。比如你一开始会用字符串来表示“电话号码”,但是随后你会发现,电话号需要“格式化”,“抽取区号”之类的特殊行为。如果这样的数据项只有一两个,你还可以把相关函数放进数据项所属的对象里,但是Duplicate Code和Feature Envy很快就会表现出来。这时,你就应该将数值变为对象。
3、Change Value toReference 将值对象改为引用对象。
你从一个类衍生出许多批次相等的实例,希望将它们替换为同一个对象。
4、Change Reference to Value 将引用对象改为值对象。
你有一个引用对象,很小且不可变,而且不易管理。
5、Replace Array with Object 以对象取代数组。
你有一个数组,其中的元素各自代表不同的东西。
改造前:
String[] row = new String[3];row[0] = "liver";row[1] = "15";
改造后:
Performance row = new Performance();row.setName("liver");row.setWins(15);
6、Duplicate Observed Data 复制“被监视数据”。
有一些领域数据置身于GUI组件中,而领域函数需要访问这些数据。
将该数据复制到一个领域对象中。建立一个Observer模式,用以同步领域对象和GUI对象内的重复数据。可以使用事件监听器,诸如JAVAFX中的Property。
7、Change Unidirectional Association to Bidirectional 将单向关联改为双向关联。
两个类都需要使用对方特性,但其间只有一条单向链接。
8、Change Bidirectional Association to Unidirectional 将双向关联改为单向关联。
两个类之间有双向关联,但其中一个类如今不再需要另一个类的特性。
9、Replace Magic Number with Symbolic Constant 以字面常量取代魔法值。
改造前:
double count(double a, double b){ return a * 0.95 * b;}
改造后:
double count(double a, double b){ return a * RATE_CONSTANT * b;}
static final double RATE_CONSTANT = 0.95;
10、Encapsulate Field 封装字段。
即面向对象的首要原则之一:封装,或称为“数据隐藏”。
改造前:
public String _name;
改造后:
private String _name;public String getName() { return _name;}public void setName(String name) { this._name = name;}
11、Encapsulate Collection 封装集合。
让这个函数返回该集合的一个只读副本,并在这个类中提供添加/移除集合元素的函数。
改造前:
class Person { List<String> classes; public List<String> getClasses(){ return classes; } public void setClasses(List<String> cls){ this.classes = cls; }}
改造后:
class Person { List<String> classes; public List<String> getClasses(){ return classes; } // setter方法隐藏,避免用户修改集合内容而一无所知 private void setClasses(List<String> cls){ this.classes = cls; } public void addClass(String cls) { classes.add(cls); } public void removeClass(String cls) { classes.remove(cls); }}
12、Replace Record with Data Class 以数据类取代记录。
主要用来应对传统编程环境中的记录结构。
13、Replace Type Code with Class 以类取代类型码。
类中有一个数值类型码,但它并不影响类的行为。
改造前:
class Person { public static final int O = 0; public static final int A = 1; public static final int B = 2; public static final int AB = 3; @Getter @Setter private int _bloodGroup; public Person(int bloodGroup) { _bloodGroup = bloodGroup; }}
改造后:
class Person { public static final int O = BloodGroup.O.getCode(); public static final int A = BloodGroup.A.getCode(); public static final int B = BloodGroup.B.getCode(); public static final int AB = BloodGroup.AB.getCode(); @Getter private int _bloodGroup; public Person(int bloodGroup) { _bloodGroup = BloodGroup.code(bloodGroup); } public void setBloodGroup(int arg) { _bloodGroup = BloodGroup.code(arg); }}class BloodGroup { public static final BloodGroup O = new BloodGroup(0); public static final BloodGroup A = new BloodGroup(1); public static final BloodGroup B = new BloodGroup(2); public static final BloodGroup AB = new BloodGroup(3); private static final BloodGroup[] _values = {A, A, B, AB}; @Getter private final int _code; private BloodGroup(int code) { _code = code; } public static BloodGroup code(int arg) { return _values[arg]; } }
14、Replace Type Code with Subclasses 以子类取代类型码。
你有一个不可变的类型码,他会影响类的行为。
15、Replace Type Code with State/Strategy 以State/Strategy取代类型码。
你有一个类型码,它会影响类的行为,但你无法通过继承手法消除他。
5. 小结
到此仅汇总了一半的重构手法,个人觉得部分重构手法是以牺牲一定的代码阅读性为代价。且书中提到的多数重构手法还是要视具体编程场景而定。避免错误引用。
重构手法和设计模式一样,均为编程模式中的最佳实践。是符合大多数场景和行为的思想或方法的总结。记住是大多数。了解最佳实践有助于提高平常的编码习惯以及提升代码的维护性,可修改性。但如果被错误引用,程序将因为过度设计或引用而变得臃肿。
持续更新中…将继续更新重构手法(下)…