重构笔记

最近刚看完了《重构-改善既有代码的设计》([美] Martin Fowler)这本书，里面介绍了很多的重构手法，

挺实用的，看的时候简单的记录了一下，不是很详细，还是分享一下吧。

 

 

 

1）提炼函数（Extract Method）  

使用场景	1、函数过长 2、全部或某一段代码块重复性太强，copy的过多
好处	1、颗粒度小，整体被复用的机会大，即不需要再多次重复内部逻辑 2、规范一个好的命名（命名长度可以很长，但一定要更好的解释此段的语义），      可以更加清晰此块代码的实际作用
实际运用	1、不需要传参，即直接提取函数段，并放入一个新的函数中即可。 2、需要传参：       1）按值传递（单值 / 多值）【JAVA规范】             单值问题上直接传递即可。             若参数值过多，可以将其封装成一个临时对象（内部类）来传递。             注意：值传递时，不要直接对参数赋值，将其当做被final修饰过                        的值来处理 。              做法：                        (1) 将待处理的参数赋值给一个临时变量。                        (2) 中间的处理部分也以指定的临时来进行运作。                        (3) 在有必要时需要返回这个临时变量。             （移除对参数的赋值【Remove Assignments to Parameters】）       2）按引用传递
备注

 

2）内联函数（Inline Method） 

使用场景	1、一般为源函数的函数体很短，很清晰易懂，且不被重复调用
好处	1、其语义本身就已经很清晰了，没必要添加成新的函数
实际运用	1、直接将源函数的函数体放入目标函数的对应位置即可
备注

      

3）以函数对象取代函数（Replace Method with Method Object）     

使用场景	1、一般为长函数中，局部变量过多，而无法很好的提炼成小函数
好处	1、将该函数存放至函数对象中之后，局部变量可转换成对象的字段来处理，       在字段的处理上整体会更加清晰一些，面向对象的概念性更强。
实际运用	1、新建一个类，类名的语义符合待处理函数的用途。 2、新建一个final修饰的字段，用来保存源对象（即源函数所处的那个对象），       并将源函数中的变量 + 参数都设置成该函数对象的字段。 3、为该函数对象新建一个构造函数，接受源对象 + 源函数本身的所有参数作为参数。 4、新建一个compute()函数，并将源函数中的函数体移植到此函数中。 5、在源函数的函数体中调用该函数对象的compute()即可。
备注

  

4）以查询取代临时变量（Replace Temp with Query）       

使用场景	1、一般为函数体中的临时变量（为另一个函数所函数的值）基本上只使用1次
好处	1、减少临时变量的使用，让代码更加清晰一些
实际运用	1、直接使用另一个函数来进行操作，而不是先使用临时变量来接收返回值
备注

 

5）分解临时变量（Split Temporary Variable）

使用场景	1、某个临时变量被使用超过一个，且即不是循环变量，也不用于收集计算结果
好处	1、对临时变量进行分解后，可对函数体进行其他形式的重构，而不必受限于临 时变量在该函数体中的变化
实际运用	1、针对每一次赋值，创建一个独立、对应的临时变量
备注

 

6）将查询函数与修改函数分离（separate Query from Modifier）   

使用场景	1、某个函数即返回对象的状态值，又修改该对象状态
好处	1、符合单一原则，不会在执行此函数的时候出现副作用
实际运用	1、建立两个函数，一个查询，一个修改
备注	在并发问题上的考量：        在高并发的时候，不仅分离成两个不同的函数，还需要保留第三个函数来        同时执行这两个函数，并将这两个函数分别声明为synchronized，且限制 他们在包(protected)级别 或 private级别

    

7）引入解释性变量（Introduce Explaining Variable）       

使用场景	1、复杂的表达式
好处	1、让表达式清晰
实际运用	1、将该复杂表达式（或其中一部分）的结果放进一个临时变量，以此便令名称来解释表达式的意图
备注	也可使用提炼函数的方法来处理

  

8）替换算法（Substitute Algorithm）   

使用场景	1、将某段复杂的逻辑转换成清晰的表达式
好处	1、理解清晰
实际运用	需要更具具体的业务逻辑来处理。 如有些部分可以使用guava / JDK8 等工具来处理会使语义更加明确
备注	也可使用提炼函数的方法来处理

    

9）搬移函数（Move Method）       

使用场景	1、在程序执行中，某个函数与其所驻类之外的另一个类有更多交流，调用后者，或被后者调用。
好处	1、降低相关类之间的耦合度
实际运用	通俗的来说就是：        在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，        或是直接将旧函数移除掉。   具体做法：         1）检查源类中被源函数所使用的一切特性（字段 或 函数），是否也可一起被搬移，              有时候搬移一组函数比搬移单个要更好。         2）检查源类的子类或父类中是否存在对该函数的其他声明。         3）在目标类中声明这个函数。         4）将源函数的代码复制到目标函数中，调整目标函数。               （1）目标函数引用了源函数的一些特性，且不能被一起搬移，则                        可以将源类的引用作为参数传递至目标函数中，或新创建函                        数来取得目标对象的这些特性。               （2）若源函数中有异常的处理，需要考虑是否需要将异常带到目                        标函数中处理还是继续留在原地。         5）修改源函数 或 将源函数移除掉：               若需要经常在源函数中引用目标函数，则尽量保留源函数。
备注

  

10）自封装字段（Self Encapsulate Field）       

使用场景	1、若某个字段提供直接访问方式，在函数中或许会因为过多的来调用而增加耦合度， 将其变得笨拙。
好处	1、面向对象概念更加清晰
实际运用	1、直接在该类中将该字段设置为private，并提供get/set方法
备注

  

11）搬移字段（Move Field）   

使用场景	1、在程序执行中，某个字段与其所驻类之外的另一个类有更多交流
好处	1、降低相关类之间的耦合度
实际运用	通俗的来说就是：        在目标类中新建此字段，用新字段替换掉所有引用了源字段函数中的源字段部分。        需要注意的是：         1）如何在源类中获取到目标字段，可在源类中添加一个目标类的引用。
备注

 

12）提炼类（Extract Class）       

使用场景	1、一个类做了本应该由两个类来做的事
好处	1、抽象更加明确，满足单一原则
实际运用	1、建立一个新类，将相关函数和字段搬移至新类中 2、如有必要，可添加新类与源类之间的对象引用
备注

  

13）将类内联化（Inline Class）     

使用场景	1、两个相关类都没有处理过多的事，可将其合并为一个类
好处	1、清理掉萎缩类，让结构变得干净
实际运用	1、建立一个新类，分别将两个类中的函数和字段搬移至新类中
备注

 

14）隐藏“委托关系”（Hide Delegate）    

使用场景	1、客户通过委托类来调用另一个对象
好处	1、隐藏其中的细节，避免客户知道其实现逻辑
实际运用	在服务类上建立客户所需要的所有函数，用以隐藏委托关系
备注	例如： 类A、B、C 需求：A不能直接获取C信息，A能直接获取B信息，B能直接获取C信息 处理：在B中委托一个函数来获取C信息，则A可直接调用B中的函数来间             接获取了C信息。

    

15）移除中间人（委托函数）（Remove Midden Man）   

使用场景	1、某个类包含了太多的委托函数
好处	1、让客户直接调用委托类，清晰
实际运用	客户直接调用委托类，不必走中间过程
备注	这和Hide Delegate并不冲突，当委托函数只有一两个时可使用隐藏委托关系， 但多了就没必要使用中间过程了，这里面有一个度需要控制。

    

16）引入外加函数（Introduce Foreign Method）     

使用场景	1、当需要为一个服务类增加一个函数时，但又修改不了服务类，一般在源码类中会遇到，  不能修改源代码，只能对其进行扩展，或重写特定函数
好处	1、根据业务需求扩展源类
实际运用	在客户类中建立一个新函数，并将服务类作为参数进行传递，且函数的返回值也为该服务类。
备注	外加函数只是权宜之计，在权限的允许下可将其加入服务类中

  

17）引入本地扩展【子类 + 包装类】（Introduce Local Extension）       

使用场景	1、同引入外加函数的使用场景一致，但不同的是当外加函数过多时即使用此重构方法
好处	1、在本地新建一个类来包含这些额外函数，让此类作为源类的子类或包装类
实际运用	1、建立一个扩展类，作为源类的子类或包装类。 2、在扩展类中加入转型构造函数：       即“接收源对象作为参数”的构造函数。        1）子类化方案：               转型构造函数需要调用父类的构造函数。         2）包装类方案：（不是太明白）               转型构造函数需要将其得到的传入参数以实例变量的形式保存下               来，用作委托对象的原对象。 3、将外加函数搬移至此类中
备注

  

18）以对象取代数据值（Replace Data Value with Object）     

使用场景	1、某个类中需要使用到另一个类的部分信息 如：在用户类User中需要知道用户所阅读的书籍信息，若需要详细了解书籍信息 可以直接将书籍类Book的引用作为User的一个字段。
好处	1、可查看更多信息，后续扩展Book类时，User类也不需要修改
实际运用	将Book的引用作为User的一个字段
备注

  

19）以工厂函数取代构造函数（Replace Constructor with Factory Method）       

使用场景	1、你希望在创建对象时不仅仅是做简单的建构动作
好处	1、将“对象创建请求的接收者”和“被创建对象所属的类”分开了， 如：Date date = DateFactory.create();     对象创建请求的接收者：原为Date，现为DateFactory.create 被创建对象所属的类：原Date类
实际运用	1、将构造函数替换为工厂函数        private Book(String name){ this.name = checkNull(name); }          public Book create(String name){              return new Book(name);    //原构造函数设为私有的        }
备注	1、当此工厂函数创建的子类只有少数几个时，可使用明确函数来创建子类       即在工厂类中添加类似如下创建函数：       public Book createBook(String name){              return new Book(name);       } 2、当需要创建的子类数量多的时候，可以使用字符串类型的类型码 + 反       射机制来控制：       static Book create(String name){              try{                     return (Book) Class.forName(name).newInstance();              } catch(Exception e){}       }         //部分代码       switch(name){            case XXX:  return create(“XXX”);            ……            default: throws new Exception(“xxxxxxx”);       }             可使用类（枚举类也可以）取代类型码

  

20）将对象替代数组（Replace Array with Object）

使用场景	1、有一个数组，但数组中每个元素又代表着不同的东西
好处	1、对象化，让所存储的每一个元素都能清晰的表达自己
实际运用	以对象替换数组，数组中的每一个元素，用字段来表示
备注

21）将单向关联改为双向关联 

使用场景	1、两个类都需要使用对方的特性，但其中只有一条单向连接
好处	1、可以双向连接
实际运用	添加一个反向指针，并使修改函数能够同时更新两条连接
备注	例如订单类 + 客户类（一个客户可以有多个不同的订单） public class Order{     private Customer _customer;     public void setCustomer(Customer customer){           if(this._customer != null)   this.customer.getOrders().remove(this);           this._customer = customer;           if(this._customer != null) this._customer.getOrders().add(this);     }     public Customer getCustomer(){           return this._customer;     } }     public class Customer{       private Set orders = Sets.newHashSet();       public Set getOrders(){           return this.orders;       } }

  

22）以字面常量取代魔法数（Replace Magic Number with Symbolic Constant） 

使用场景	1、有一个带有特别含义的字面数值
好处	1、修改、查找时都会方便
实际运用	创造一个静态常量，命名很重要，其值则为那个字面数值
备注

 

23）封装字段（Encapsulate Field）

使用场景	1、将Public定义的字段变成private的
好处	1、对象化字段
实际运用	将字段改成private的修饰符，再提供其get/set函数
备注	自封装字段和这一个概念

 

24）封装集合（Encapsulate Collection）

使用场景	1、函数返回一个集合
好处	1、避免直接去操作所返回的那个集合
实际运用	新建一个集合用作所返回集合的一个只读副本，并在这个类中提供增加/移除集合元素的函数。 List list = service.findAll(); List res = Collections.unmodifiableList(list); 之后的操作都在只读集合res中操作，避免破坏原list
备注	Collections.unmodifiableList(list);  //得到集合的只读副本

 

25）以子类取代类型码（Replace Type Code with Subclasses）

 

使用场景	1、有一个不可变的类型码，但它会影响宿主类的行为
好处
实际运用	以子类取代这个类型码。 1、使用自封装字段方式将类型码封装起来，如果类型码为构造函数的参          数，则需要将构造函数换成工厂函数。 2、为类型码的每个数值建立一个对应的子类，并复写父类获取类型码的函       数，返回对应的类型码
备注	此方法仍不够好，仍需要switch表达式的介入，下面介绍的的重构手法将完全去除掉switch语句

 

26）以多态取代条件表达式（Replace Conditional with Polymorphism）

使用场景	1、有一个条件表达式，需要根据对象类型的不同而选择不同的行为
好处	简化了条件表达式
实际运用	将这个条件表达式的每个分支放进一个子类的覆写函数中，然后将原始函数声明为抽象函数。
备注

 

27）以字段取代子类（Replace Subclass with Fields）

使用场景	1、当各个子类的唯一差别仅是“返回常量数据”不同时可使用
好处	较少子类
实际运用	1、在所有子类中通过工厂函数的方式重构其构造函数 2、其他直接引用了子类的地方，都改换成引用超类 3、针对子类中的每一个常量函数，在超类中对应声明一个final字段 4、在超类中声明一个protected构造函数，用来初始化新增的字段 5、使用内联函数方法将子类构造函数内联到超类的工厂函数中 6、再在超类中实现所有的常量函数，且返回对应的字段 7、删除子类
备注

 

28）分解条件表达式（Decompose Conditional）

使用场景	1、if、then、else条件语句过多
好处	结构清晰
实际运用	将if、then、else段落中分别提炼出独立的函数
备注

 

29）合并条件表达式（Consolidate Conditional Expression）

使用场景	1、有一系列的条件测试，但都得到相同的结果
好处	结构清晰
实际运用	将这个测试合并为一个条件表达式，并将这个条件表达式提炼成一个函数
备注	三目运算符在重构方面使用也挺好的

 

29）合并重复的条件片段（Consolidate Duplicate Conditional Fragments）

使用场景	1、在条件表达式的每个分支上有着相同的一段代码
好处	去重
实际运用	将重复代码搬移到条件表达式之外
备注

 

30）移除控制标记（Remove Control Flag）

使用场景	1、在一系列布尔表达式中，某个变量带有“控制标记”的作用
好处	当使用控制标记时，其他使用者不能一下看明白这个标记的意思， 因此使用此重构方式来简化代码结构
实际运用	找出对标记变量赋值的语句，适当的使用break、continue或return来取代控制标记
备注

 

31）使用卫语句来取代嵌套条件表达式（Replace Nested Conditional with Guard Clauses）

使用场景	1、函数中的条件逻辑太多使人难以看清正常的执行路径
好处	结构清晰
实际运用	对于每个检查，放进一个卫语句（卫语句要不就从函数中返回，要不就抛出一个异常）
备注	卫语句： 如果某个条件极其罕见，就应该单独检查该条件，并在该条件为真时立刻从函数中返回。 这样的单独检查就是“卫语句”。

 

32）以多态取代条件表达式（Replace Conditional with Polymorphism）

使用场景	1、以多态取代条件表达式
好处	减少switch、if、else等语句的出现，更重要的是多态可降低系统各部分之间的依赖， 在碰到新的修改时，不必直接去修改条件表达式，而是以新增子类的形式来完善即可
实际运用	将这个条件表达式的每个分支放进一个子类内的复写函数中，然后将原始函数声明为抽象函数
备注

 

33）函数重命名（Rename Method）

使用场景	1、函数的命名不能直接看出函数的用途
好处	看其名，知其意
实际运用	为该删除命一个好的名字。 1、先为这段函数写一段注释 2、根据注释来为其命名
备注

 

34）添加参数（Add Parameter）

使用场景	1、某个函数需要从嗲用端得到更多的信息
好处
实际运用	若函数参数过多，可自己封装一个参数对象来进行传递，或使用现成的对象来进行传递
备注	既然有添加参数，那当然也有移除参数，和此重构相反，就不多说了

 

35）将查询函数和修改函数分离（Separate Query from Modifier）

使用场景	1、某个函数既返回对象状态值，又修改对象状态
好处	减小因某次修改会产生副作用的概率
实际运用	建立两个不同的函数，其中一个负责查询，另一个负责修改
备注

 

36）令函数携带参数（Parameterize Method）

使用场景	1、若干个函数做了类似的工作，但在函数本体中却包含了不同的值
好处	简化重复代码
实际运用	建立单一函数，以参数表达那些不同的值
备注	将少量数值看做参数，来找出有重复性的代码

 

37）以明确函数取代参数（Replace Parameter with Explicit Methods）

使用场景	1、存在一个函数，其中完全取决于参数值而采取不同行为
好处
实际运用	针对该参数的每一个可能的值，建立一个独立的函数
备注

 

38）保持对象完整（Preserve Whole Object）

使用场景	1、从对象中取出若干值来当做参数进行传递
好处
实际运用	直接传递整个对象
备注	和引入参数对象（Introduce Parameter Object）重构方式一样

 

39）以函数替代临时参数（Replace Parameter with Methods）

使用场景	1、对象调用某个函数，并将所得结果作为参数，传递给另一个函数。 而接受该函数的函数本身也能够调用前一个函数。
好处	减少临时变量的使用
实际运用	让参数接受者去除该项参数，并直接使用前一个函数
备注	也要分情况来考虑： 当原函数返回的值在当前函数的很多地方都会使用时，可使用变量先接住原函数的返回值。 当其他地方使用很少时并且函数的执行不会消耗提多资源时，可直接使用函数来替代此参数。

 

40）移除设值函数（Remove Setting Method）

使用场景	1、类中的某个字段应该在对象创建时被设值，然后就不再改变
好处
实际运用	去掉该字段的所有设值函数，在构造函数中进行赋值
备注

 

41）隐藏函数（Hide Method）

使用场景	1、未使用的函数
好处
实际运用	使用private来进行隐藏，降低函数的可见度
备注

 

42）以异常取代错误码（Replace Error Code with Exception）

使用场景	1、某个函数返回一个特定的代码，用来表示某种错误情况
好处
实际运用	改为返回异常
备注

  

43、字段上移

44、函数上移

45、字段下移

46、函数下移

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

使用场景	1、在多个子类的构造函数中，其本体几乎都一致
好处
实际运用	在超类中新建一个构造函数，并在子类构造函数中调用它
备注

 

48、提炼子类

49、提炼父类

50、提炼接口

51）塑造模板函数（Form Template Method）

使用场景	1、在一些子类中，其中相应的某些函数以相同的顺序执行类似的操作， 但各个操作的细节上又有所不同
好处
实际运用	将这些操作分别放进独立的函数中，并保持他们都有相同的签名， 于是原函数也就变得相同了，然后将原函数上移至超类中。 说白了，就是将不同的地方通过分解/封装转换成相同的部分，再将相同之处提炼至父类中。
备注	分解目标函数时需要注意

 

52）以委托取代继承（Replace Inheritance with Delegation）

使用场景	1、某个子类只能使用超类接口中的一部分，或是根本不需要继承而来的数据
好处
实际运用	在子类中新建一个字段用以保存超类；调整子类函数，令它改而委托超类；然后去掉继承。 1、在子类中新增一个字段，并new一个超类的实例 2、在有调用超类函数的地方修改为使用新增的字段来调用
备注	同时，也有以继承取代委托的重构方法，当然了，其用法也正好相反

 

 

 

最近也在看秦小波的《设计模式之禅》，写的也挺好的