网站建设前期分析的内容,广州市天河区,网站里的个人中心下拉列表怎么做,南宁网站seo1. 前言
之前的重构系列中#xff0c;介绍了书中提到的重构基础#xff0c;以及识别代码的坏味道。今天继续第三更#xff0c;讲述那些重构手法#xff08;上#xff09;。看看哪些手法对你的项目能有所帮助…
2. 重新组织函数
对函数进行整理#xff0c;使之更恰当的…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() 10004、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 {ListString classes;public ListString getClasses(){return classes; }public void setClasses(ListString cls){this.classes cls;}
}改造后
class Person {ListString classes;public ListString getClasses(){return classes; }// setter方法隐藏避免用户修改集合内容而一无所知private void setClasses(ListString 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;GetterSetterprivate 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();Getterprivate 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}; Getterprivate 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. 小结
到此仅汇总了一半的重构手法个人觉得部分重构手法是以牺牲一定的代码阅读性为代价。且书中提到的多数重构手法还是要视具体编程场景而定。避免错误引用。 重构手法和设计模式一样均为编程模式中的最佳实践。是符合大多数场景和行为的思想或方法的总结。记住是大多数。了解最佳实践有助于提高平常的编码习惯以及提升代码的维护性可修改性。但如果被错误引用程序将因为过度设计或引用而变得臃肿。 持续更新中…将继续更新重构手法下…
