重构

Chapter 1： Refactoring， a First Example 1

The Starting Point 1

The First Step in Refactoring 7

Decomposing and Redistributing the Statement Method 8

Replacing the Conditional Logic on Price Code with Polymorphism 34

Final Thoughts 52

Chapter 2： Principles in Refactoring 53

Defining Refactoring 53

Why Should You Refactor 55

When Should You Refactor 57

What Do I Tell My Manager 60

Problems with Refactoring 62

Refactoring and Design 66

Refactoring and Performance 69

Where Did Refactoring Come From 71

Chapter 3： Bad Smells in Code （by Kent Beck and Martin Fowler） 75

Duplicated Code 76

Long Method 76

Large Class 78

Long Parameter List 78

Divergent Change 79

Shotgun Surgery 80

Feature Envy 80

Data Clumps 81

Primitive Obsession 81

Switch Statements 82

Parallel Inheritance Hierarchies 83

Lazy Class 83

Speculative Generality 83

Temporary Field 84

Message Chains 84

Middle Man 85

Inappropriate Intimacy 85

Alternative Classes with Different Interfaces 85

Incomplete Library Class 86

Data Class 86

Refused Bequest 87

Comments 87

Chapter 4： Building Tests 89

The Value of Self-testing Code 89

The JUnit Testing Framework 91

Adding More Tests 97

Chapter 5： Toward a Catalog of Refactorings 103

Format of the Refactorings 103

Finding References 105

How Mature Are These Refactorings 106

Chapter 6： Composing Methods 109

Extract Method 110

Inline Method 117

Inline Temp 119

Replace Temp with Query 120

Introduce Explaining Variable 124

Split Temporary Variable 128

Remove Assignments to Parameters 131

Replace Method with Method Object 135

Substitute Algorithm 139

Chapter 7： Moving Features Between Objects 141

Move Method 142

Move Field 146

Extract Class 149

Inline Class 154

Hide Delegate 157

Remove Middle Man 160

Introduce Foreign Method 162

Introduce Local Extension 164

Chapter 8： Organizing Data 169

Self Encapsulate Field 171

Replace Data Value with Object 175

Change Value to Reference 179

Change Reference to Value 183

Replace Array with Object 186

Duplicate Observed Data 189

Change Unidirectional Association to Bidirectional 197

Change Bidirectional Association to Unidirectional 200

Replace Magic Number with Symbolic Constant 204

Encapsulate Field 206

Encapsulate Collection 208

Replace Record with Data Class 217

Replace Type Code with Class 218

Replace Type Code with Subclasses 223

Replace Type Code with State/Strategy 227

Replace Subclass with Fields 232

Chapter 9： Simplifying Conditional Expressions 237

Decompose Conditional 238

Consolidate Conditional Expression 240

Consolidate Duplicate Conditional Fragments 243

Remove Control Flag 245

Replace Nested Conditional with Guard Clauses 250

Replace Conditional with Polymorphism 255

Introduce Null Object 260

Introduce Assertion 267

Chapter 10： Making Method Calls Simpler 271

Rename Method 273

Add Parameter 275

Remove Parameter 277

Separate Query from Modifier 279

Parameterize Method 283

Replace Parameter with Explicit Methods 285

Preserve Whole Object 288

Replace Parameter with Method 292

Introduce Parameter Object 295

Remove Setting Method 300

Hide Method 303

Replace Constructor with Factory Method 304

Encapsulate Downcast 308

Replace Error Code with Exception 310

Replace Exception with Test 315

Chapter 11： Dealing with Generalization 319

Pull Up Field 320

Pull Up Method 322

Pull Up Constructor Body 325

Push Down Method 328

Push Down Field 329

Extract Subclass 330

Extract Superclass 336

Extract Interface 341

Collapse Hierarchy 344

Form Template Method 345

Replace Inheritance with Delegation 352

Replace Delegation with Inheritance 355

Chapter 12： Big Refactorings （by Kent Beck and Martin Fowler） 359

Tease Apart Inheritance 362

Convert Procedural Design to Objects 368

Separate Domain from Presentation 370

Extract Hierarchy 375

Chapter 13： Refactoring， Reuse， and Reality （by William Opdyke） 379

A Reality Check 380

Why Are Developers Reluctant to Refactor Their Programs 381

A Reality Check （Revisited） 394

Resources and References for Refactoring 394

Implications Regarding Software Reuse and Technology Transfer 395

A Final Note 397

References 397

Chapter 14： Refactoring Tools （by Don Roberts and John Brant） 401

Refactoring with a Tool 401

Technical Criteria for a Refactoring Tool 403

Practical Criteria for a Refactoring Tool 405

Wrap Up 407

Chapter 15： Putting It All Together （by Kent Beck） 409

References 413

List of Soundbites 417

Index 419

《重构：改善既有代码的设计（英文版）》清晰揭示了重构的过程，解释了重构的原理和最佳实践方式，并给出了何时以及何地应该开始挖掘代码以求改善。书中给出了70多个可行的重构，每个重构都介绍了一种经过验证的代码变换手法的动机和技术。《重构：改善既有代码的设计（英文版）》提出的重构准则将帮助你一次一小步地修改你的代码，从而减少了开发过程中的风险。

重构，一言以蔽之，就是在不改变外部行为的前提下，有条不紊地改善代码。多年前，正是《重构：改善既有代码的设计（英文版）》原版的出版，使重构终于从编程高手们的小圈子走出，成为众多普通程序员日常开发工作中不可或缺的一部分。《重构：改善既有代码的设计（英文版）》也因此成为与《设计模式》齐名的经典著作，被译为中、德、俄、日等众多语富，在世界范围内畅销不衰。
《重构：改善既有代码的设计（英文版）》凝聚了软件开发社区专家多年摸索而获得的宝贵经验，拥有不因时光流逝而磨灭的价值。今天，无论是重构本身，业界对重构的理解，还是开发工具对重构的支持力度，都与《重构：改善既有代码的设计（英文版）》最初出版时不可同日而语，但书中所蕴涵的意昧和精华，依然值得反复咀嚼，而且往往能够常读常新。