重构

作者简介

重构，一言以蔽之，就是在不改变外部行为的前提下，有条不紊地改善代码。多年前，正是本书原版的出版，使重构终于从编程高手们的小圈子走出，成为众多普通程序员日常开发工作中不可或缺的一部分。本书也因此成为与《设计模式》齐名的经典著作，被译为中、德、俄、日等众多语言，在世界范围内畅销不衰。

本书凝聚了软件开发社区专家多年摸索而获得的宝贵经验，拥有不因时光流逝而磨灭的价值。今天，无论是重构本身，业界对重构的理解，还是开发工具对重构的支持力度，都与本书最初出版时不可同日而语，但书中所蕴涵的意味和精华，依然值得反复咀嚼，而且往往能够常读常新。

书籍目录

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 Class86

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

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 Generalization319

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 Note397

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

编辑推荐

《重构:改善既有代码的设计(英文版)》：软件开发的不朽经典、生动阐述重构原理和具体做法、普通程序员进阶到编程高手必须修炼的秘笈。

前言

"重构"这个概念来自Smalltalk圈子，没多久就进入了其他语言阵营之中。由于重构是框架开发中不可缺少的一部分，所以当框架开发人员讨论自己的工作时，这个术语就诞生了。当他们精练自己的类继承体系时，当他们叫喊自己可以拿掉多少多少行代码时，重构的概念慢慢浮出水面。框架设计者知道，这东西不可能一开始就完全正确，它将随着设计者的经验成长而进化；他们也知道，代码被阅读和被修改的次数远远多于它被编写的次数。保持代码易读、易修改的关键，就是重构——对框架而言如此，对一般软件也如此。好极了，还有什么问题吗？问题很显然：重构具有风险。它必须修改运作中的程序，这可能引入一些不易察觉的错误。如果重构方式不恰当，可能毁掉你数天甚至数星期的成果。如果重构时不做好准备，不遵守规则，风险就更大。你挖掘自己的代码，很快发现了一些值得修改的地方，于是你挖得更深。挖得愈深，找到的重构机会就越多，于是你的修改也愈多……最后你给自己挖了个大坑，却爬不出去了。为了避免自掘坟墓，重构必须系统化进行。我在《设计模式》书中和另外三位作者曾经提过：设计模式为重构提供了目标。然而"确定目标"只是问题的一部分而已，改造程序以达到目标，是另一个难题。

内容概要

Martin Fowler  世界软件开发大师，在面向对象分析设计、UML、模式、XP和重构等领域都有卓越贡献，现为著名软件开发咨询公司ThoughtWorks的首席科学家。他的多部著作《分析模式》、《UML精粹》和《企业应用架构模式》等都已经成为脍炙人口的经典。

其他参编者

Kent Beck 软件开发方法学的泰斗，极限编程的创始人。他是Three Rivers Institute公司总裁，也是Agitar Software的成员。

John Brant和Don Roberts The Refactory公司的创始人，Refactoring Browser http://st-www.cs.illinois.edu/users/brant/Refactory/）的开发者，多年来一直从事研究重构的实践与理论。

William Opdyke  目前在朗讯贝尔实验室工作，他写的关于面向对象框架的博士论文是重构方面的第一篇著名文章。

章节摘录

插图：Any technical author has the problem of deciding when to publish. The earlieryou publish, the quicker people can take advantage of the ideas. However, people are always learning. If you publish half-baked ideas too early, the ideas canbe incomplete and even lead to problems for those who try to use them.   The basic technique of refactoring, taking small steps and testing often, hasbeen well tested over many years, especially in the Smalltalk community. So I'mconfident that the basic idea of refactoring is very stable.   The refactorings in this book are my notes about the refactorings I use. Ihave used them all. However, there is a difference between using a refactoringand boiling it down into the mechanical steps I give herein. In particular, youoccasionally see problems that crop up only in very specific circumstances. Icannot say that I have had a lot of people work from these steps to spot many of these kinds of problems. As you use the refactorings, be aware of what youare doing. Remember that like working with a recipe, you have to adapt the refactorings to your circumstances. If you run into an interesting problem, dropme an e-mail, and I'll try to pass on these circumstances for others.

图书封面

---

 重构下载 精选章节试读

---