代码大全学习-27-重构(Refactoring)

重构是改变软件的内在结构从而让其更好理解更容易修改。在软件开发过程中随处可见它的身影。很多地方都可以用重构来改善，比如重复的代码，太长的函数，嵌套很深的循环等，下面是一个比较完整的list，需要重构的原因：

Checklist: Reasons to Refactor

• Code is duplicated
• A routine is too long
• A loop is too long or too deeply nested
• A class has poor cohesion
• A class interface does not provide a consistent level of abstraction
• A parameter list has too many parameters
• Changes within a class tend to be compartmentalized
• Changes require parallel modifications to multiple classes
• Inheritance hierarchies have to be modified in parallel
• Related data items that are used together are not organized into classes
• A routine uses more features of another class than of its own class
• A primitive data type is overloaded
• A class doesn't do very much
• A chain of routines passes tramp data
• A middle man object isn't doing anything
• One class is overly intimate with another
• A routine has a poor name
• Data members are public
• A subclass uses only a small percentage of its parents' routines
• Comments are used to explain difficult code
• Global variables are used
• A routine uses setup code before a routine call or takedown code after a routine call
• A program contains code that seems like it might be needed someday

当我们看到这些现象出现的时候，就要考虑一下重构了。重构的方法很多，所以要分成不同的层次来列举，一下子太多了人会看晕。下面的列表从数据、语句、函数、类、系统等六个层次列举了重构用到的方法，这里只是一个提纲，详细方法太多，可以去查看原书，还有Fowler Martin的《重构》一书。

Checklist: Summary of Refactorings

Data Level Refactoring

• Replace a magic number with a named constant
• Rename a variable with a clearer or more informative name
• Move an expression inline
• Replace an expression with a routine
• Introduce an intermediate variable
• Convert a multi-use variable to a multiple single-use variables
• Use a local variable for local purposes rather than a parameter
• Convert a data primitive to a class
• Convert a set of type codes to a class
• Convert a set of type codes to a class with subclasses
• Change an array to an object
• Encapsulate a collection
• Replace a traditional record with a data class

Statement Level Refactorings

• Decompose a boolean expression
• Move a complex boolean expression into a well-named boolean function
• Consolidate fragments that are duplicated within different parts of a conditional
• Use break or return instead of a loop control variable
• Return as soon as you know the answer instead of assigning a return value within nested if-then-else statements
• Replace conditionals with polymorphism (especially repeated case statements)
• Create and use null objects instead of testing for null values

Routine Level Refactorings

• Extract a routine
• Move a routine's code inline
• Convert a long routine to a class
• Substitute a simple algorithm for a complex algorithm
• Add a parameter
• Remove a parameter
• Separate query operations from modification operations
• Combine similar routines by parameterizing them
• Separate routines whose behavior depends on parameters passed in
• Pass a whole object rather than specific fields
• Pass specific fields rather than a whole object
• Encapsulate downcasting

Class Implementation Refactorings

• Change value objects to reference objects
• Change reference objects to value objects
• Replace virtual routines with data initialization
• Change member routine or data placement
• Extract specialized code into a subclass
• Combine similar code into a superclass

Class Interface Refactorings

• Move a routine to another class
• Convert one class to two
• Eliminate a class
• Hide a delegate
• Replace inheritance with delegation
• Replace delegation with inheritance
• Remove a middle man
• Introduce a foreign routine
• Introduce a class extension
• Encapsulate an exposed member variable
• Remove Set() routines for fields that cannot be changed
• Hide routines that are not intended to be used outside the class
• Encapsulate unused routines
• Collapse a superclass and subclass if their implementations are very similar

System Level Refactorings

• Duplicate data you can't control
• Change unidirectional class association to bidirectional class association
• Change bidirectional class association to unidirectional class association
• Provide a factory routine rather than a simple constructor
• Replace error codes with exceptions or vice versa

重构是一种改变，所以要控制它所带来的影响，保证重构的安全。我们是出于改善的目的去重构，若是反而弄得更糟，就得不偿失了。所以也要注意下面所列举的注意事项，重构的时候注意检查。

Checklist: Refactoring Safely

• Is each change part of a systematic change strategy?
• Did you save the code you started with before beginning refactoring?
• Are you keeping each refactoring small?
• Are you doing refactorings one at a time?
• Have you made a list of steps you intend to take during your refactoring?
• Do you have a parking lot so that you can remember ideas that occur to you mid-refactoring?
• Have you retested after each refactoring?
• Have changes been reviewed if they are complicated or if they affect mission-critical code?
• Have you considered the riskiness of the specific refactoring, and adjusted your approach accordingly?
• Does the change enhance the program's internal quality rather than degrading it?
• Have you avoided using refactoring as a cover for code and fix or as an excuse for not rewriting bad code?

开发过程中的重构是提高代码质量的最好机会，不要错过，尽可能把它改好。