面向对象程序设计：英文本

Preface v

1 Thinking Object-Oriented 1

1.1 Why Is OOP Popular? 2

1.2 Language and Thought. 2

1.2.1 Eskimos and Snow3

1.2.2 An Example from Computer Languages3

1.2.3 Church's Conjecture and the Whorf Hypothesis * 5

1.3 A New Paradigm6

1.4 A Way of Viewing the World.8

1.4.1 Agents and Communities8

1.4.2 Messages and Methods.9

1.4.3 Responsibilities 11

1.4.4 Classes and Instances.11

1.4.5 Class Hierarchies{Inheritance. 11

1.4.6 Method Binding and Overriding. 14

1.4.7 Summary of Object-Oriented Concepts14

1.5 Computation as Simulation *.15

1.5.1 The Power of Metaphor. 16

1.5.2 Avoiding In nite Regression 18

1.6 A Brief History *18

2 Abstraction 25

2.1 Layers of Abstraction 26

2.2 Other Forms of Abstraction.30

2.2.1 Division into Parts31

2.2.2 Encapsulation and Interchangeability 32

2.2.3 Interface and Implementation. 33

2.2.4 The Service View. 33

2.2.5 Composition34

2.2.6 Layers of Specialization. 35

2.2.7 Patterns. 38

2.3 A Short History of Abstraction Mechanisms*. 39

2.3.1 Assembly Language.39

2.3.2 Procedures. 39

2.3.3 Modules. 41

2.3.4 Abstract Data Types.42

2.3.5 A Service-Centered View43

2.3.6 Messages, Inheritance, and Polymorphism44

3 Object-Oriented Design 49

3.1 Responsibility Implies Noninterference49

3.2 Programming in the Small and in the Large 50

3.3 Why Begin with Behavior?.51

3.4 A Case Study in RDD 52

3.4.1 The Interactive Intelligent Kitchen Helper52

3.4.2 Working through Scenarios 53

3.4.3 Identi cation of Components. 55

3.5 CRC Cards{Recording Responsibility55

3.5.1 Give Components a Physical Representation 56

3.5.2 The What/Who Cycle.56

3.5.3 Documentation 57

3.6 Components and Behavior57

3.6.1 Postponing Decisions.59

3.6.2 Preparing for Change.59

3.6.3 Continuing the Scenario. 60

3.6.4 Interaction Diagrams.61

3.7 Software Components 62

3.7.1 Behavior and State62

3.7.2 Instances and Classes.63

3.7.3 Coupling and Cohesion. 63

3.7.4 Interface and Implementation{Parnas's Principles 64

3.8 Formalize the Interface 65

3.8.1 Coming up with Names. 65

3.9 Designing the Representation.66

3.10 Implementing Components.67

3.11 Integration of Components.68

3.12 Maintenance and Evolution.69

4 Classes and Methods 73

4.1 Encapsulation 73

4.2 Class De nitions74

4.2.1 C++, Java and C#.75

4.2.2 Apple Object Pascal and Delphi Pascal77

4.2.3 Smalltalk77

4.2.4 Other Languages. 79

4.3 Methods.79

4.3.1 Order of Methods in a Class Declaration 82

4.3.2 Constant or Immutable Data Fields 82

4.3.3 Separating De nition and Implementation83

4.4 Variations on Class Themes*.87

4.4.1 Methods without Classes in Oberon 87

4.4.2 Interfaces88

4.4.3 Properties89

4.4.4 Forward De nitions.90

4.4.5 Inner or Nested Classes. 91

4.4.6 Class Data Fields. 94

4.4.7 Classes as Objects96

5 Messages, Instances, and Initialization 101

5.1 Message-Passing Syntax. 101

5.2 Statically and Dynamically Typed Languages. 103

5.3 Accessing the Receiver from Within a Method. 104

5.4 Object Creation. 106

5.4.1 Creation of Arrays of Objects. 107

5.5 Pointers and Memory Allocation108

5.5.1 Memory Recovery109

5.6 Constructors 110

5.6.1 The Orthodox Canonical Class Form*. 114

5.6.2 Constant Values. 115

5.7 Destructors and Finalizers117

5.8 Metaclasses in Smalltalk*119

6 A Case Study: The Eight Queens Puzzle 125

6.1 The Eight-Queens Puzzle125

6.1.1 Creating Objects That Find Their Own Solution 126

6.2 Using Generators127

6.2.1 Initialization127

6.2.2 Finding a Solution129

6.2.3 Advancing to the Next Position130

6.3 The Eight-Queens Puzzle in Several Languages130

6.3.1 The Eight-Queens Puzzle in Object Pascal 131

6.3.2 The Eight-Queens Puzzle in C++.134

6.3.3 The Eight-Queens Puzzle in Java. 136

6.3.4 The Eight-Queens Puzzle in Objective-C139

6.3.5 The Eight-Queens Puzzle in Smalltalk. 141

6.3.6 The Eight-Queens Puzzle in Ruby143

7 A Case Study: A Billiards Game 147

7.1 The Elements of Billiards147

7.2 Graphical Objects. 148

7.2.1 The Wall Graphical Object 149

7.2.2 The Hole Graphical Object 150

7.2.3 The Ball Graphical Object 151

7.3 The Main Program. 155

7.4 Using Inheritance155

8 Inheritance and Substitution 161

8.1 An Intuitive Description of Inheritance161

8.1.1 The Is-a Test162

8.1.2 Reasons to Use Inheritance 162

8.2 Inheritance in Various Languages163

8.3 Subclass, Subtype, and Substitution. 163

8.3.1 Substitution and Strong Typing*. 167

8.4 Overriding and Virtual Methods167

8.5 Interfaces and Abstract Classes. 169

8.6 Forms of Inheritance170

8.6.1 Subclassing for Specialization (Subtyping)170

8.6.2 Subclassing for Speci cation 171

8.6.3 Subclassing for Construction. 171

8.6.4 Subclassing for Generalization172

8.6.5 Subclassing for Extension173

8.6.6 Subclassing for Limitation173

8.6.7 Subclassing for Variance. 173

8.6.8 Subclassing for Combination. 174

8.6.9 Summary of the Forms of Inheritance. 174

8.7 Variations on Inheritance*175

8.7.1 Anonymous Classes in Java 175

8.7.2 Inheritance and Constructors. 176

8.7.3 Virtual Destructors177

8.8 The Bene ts of Inheritance.178

8.8.1 Software Reusability.178

8.8.2 Code Sharing178

8.8.3 Consistency of Interface. 178

8.8.4 Software Components.178

8.8.5 Rapid Prototyping179

8.8.6 Polymorphism and Frameworks179

8.8.7 Information Hiding179

8.9 The Costs of Inheritance. 180

8.9.1 Execution Speed. 180

8.9.2 Program Size180

8.9.3 Message-Passing Overhead 180

8.9.4 Program Complexity.181

9 Case study { A Card Game 185

9.1 The Class PlayingCard 185

9.2 Data and View Classes 187

9.3 The Game. 188

9.4 Card Piles{Inheritance in Action189

9.4.1 The Default Card Pile.191

9.4.2 The Suit Piles 192

9.4.3 The Deck Pile 192

9.4.4 The Discard Pile. 194

9.4.5 The Tableau Piles195

9.5 Playing the Polymorphic Game. 197

9.6 The Graphical User Interface.197

10 Subclasses and Subtypes 205

10.1 Substitutability. 205

10.2 Subtypes. 206

10.3 The Substitutability Paradox.208

10.3.1 Is This a Problem?210

10.4 Subclassing for Construction.210

10.4.1 Private Inheritance in C++*. 212

10.5 Dynamically Typed Languages. 213

10.6 Pre and Post conditions*214

10.7 Re nement Semantics* 214

11 Static and Dynamic Behavior 219

11.1 Static versus Dynamic Typing.219

11.2 Static and Dynamic Classes.221

11.2.1 Run Time Type Determination223

11.2.2 Down Casting (Reverse Polymorphism)223

11.2.3 Run Time Testing without Language Support* . 226

11.2.4 Testing Message Understanding227

11.3 Static versus Dynamic Method Binding. 227

12 Implications of Substitution 233

12.1 Memory Layout. 233

12.1.1 Minimum Static Space Allocation235

12.1.2 Maximum Static Space Allocation237

12.1.3 Dynamic Memory Allocation. 238

12.2 Assignment239

12.2.1 Assignment in C++*.240

12.3 Copies and Clones. 243

12.3.1 Copies in Smalltalk and Objective-C 243

12.3.2 Copy Constructors in C++ 243

12.3.3 Cloning in Java ..244

12.4 Equality.244

12.4.1 Equality and Identity.245

12.4.2 The Paradoxes of Equality Testing246

13 Multiple Inheritance 251

13.1 Inheritance as Categorization.252

13.1.1 Incomparable Complex Numbers. 252

13.2 Problems Arising from Multiple Inheritance 254

13.2.1 Name Ambiguity. 255

13.2.2 Impact on Substitutability257

13.2.3 Rede nition in Eiel*.258

13.2.4 Resolution by Class Ordering in CLOS*259

13.3 Multiple Inheritance of Interfaces261

13.3.1 Mixins in CLOS*. 263

13.4 Inheritance from Common Ancestors. 265

13.4.1 Constructors and Multiple Inheritance*268

13.5 Inner Classes 269

14 Polymorphism and Software Reuse 273

14.1 Polymorphism in Programming Languages273

14.1.1 Many Tools, One Goal.275

14.2 Mechanisms for Software Reuse. 275

14.2.1 Using Composition276

14.2.2 Using Inheritance. 278

14.2.3 Composition and Inheritance Contrasted279

14.3 E ciency and Polymorphism.281

14.4 Will Widespread Software Reuse Become Reality? 282

15 Overloading 285

15.1 Type Signatures and Scopes.285

15.2 Overloading Based on Scopes.287

15.3 Overloading Based on Type Signatures288

15.3.1 Coercion and Conversion291

15.4 Rede nition297

15.5 Polyadicity*299

15.5.1 Optional Parameters.301

15.6 Multi-Methods*. 302

15.6.1 Overloading Based on Values. 304

16 Overriding 307

16.0.2 Overriding in Smalltalk Class Magnitude308

16.1 Notating Overriding309

16.2 Replacement versus Re nement. 309

16.2.1 Replacement in Smalltalk311

16.2.2 Re nement in Beta313

16.2.3 Re nement and the Subclass/Subtype distinction 316

16.2.4 Wrappers in CLOS316

16.3 Deferred Methods317

16.4 Overriding versus Shadowing.318

16.5 Covariance and Contravariance. 321

16.6 Variations on Overriding*326

16.6.1 Final methods in Java.326

16.6.2 Versioning in C#. 327

17 The Polymorphic Variable 331

17.1 Simple Polymorphic Variables.331

17.2 The Receiver Variable 333

17.2.1 The role of the polymorphic variable in frameworks . 334

17.2.2 Endpoint comparisons in Smalltalk336

17.2.3 Self and Super 337

17.3 Downcasting 339

17.4 Pure Polymorphism341

18 Generics 345

18.1 Template Functions345

18.2 Template Classes347

18.2.1 Bounded Genericity*.349

18.3 Inheritance in Template Arguments*. 349

18.3.1 Inheritance and Arrays. 351

18.4 Case Study-Combining Separate Classes. 352

19 Container Classes 359

19.1 Containers in Dynamically Typed Languages. 359

19.1.1 Containers in Smalltalk-80 360

19.2 Containers in Statically-Typed Languages361

19.2.1 The Tension between Typing and Reuse362

19.2.2 Substitution and Downcasting364

19.2.3 Using Substitution and Overriding368

19.2.4 Parametrized Classes.370

19.3 Restricting Element Types*.371

19.4 Element Traveral374

19.4.1 Iterator loops375

19.4.2 The Visitor Approach.377

20 A Case Study: The STL 385

20.1 Iterators.387

20.2 Function Objects388

20.3 Example Program{An Inventory System. 390

20.4 Example Program{Graphs392

20.4.1 Shortest Path Algorithm. 394

20.4.2 Developing the Data Structures394

20.5 A Concordance. 398

20.6 The Future of OOP401

21 Frameworks 403

21.1 Reuse and Specialization. 403

21.1.1 High and low level abstractions406

21.1.2 An Upside Down Library408

21.2 Example Frameworks409

21.2.1 The Java Applet API.409

21.2.2 A Simulation Framework410

21.2.3 An Event-Driven Simulation Framework411

22 An Example Framework: The AWT and Swing 419

22.1 The AWT Class Hierarchy ...419

22.2 The Layout Manager422

22.3 Listeners.424

22.3.1 Adapter Classes. 425

22.4 User Interface Components.426

22.5 Case Study: A Color Display.429

22.6 The Swing component library.432

22.6.1 Import Libraries. 433

22.6.2 Dierent Components.433

22.6.3 Dierent Paint Protocol. 433

22.6.4 Adding Components to a Window434

23 Object Interconnections 435

23.1 Coupling and Cohesion 436

23.1.1 Varieties of Coupling.436

23.1.2 Varieties of Cohesion.439

23.1.3 The Law of Demeter.440

23.1.4 Class-Level versus Object-Level Visibility442

23.1.5 Active Values442

23.2 Subclass Clients and User Clients444

23.3 Control Of Access and Visibility445

23.3.1 Visibility in Smalltalk.445

23.3.2 Visibility in Object Pascal445

23.3.3 Visibility in C++.446

23.3.4 Visibility in Java. 450

23.3.5 Visibility in Objective-C. 452

23.4 Intentional Dependency. 453

24 Design Patterns 457

24.1 Controlling Information Flow.458

24.2 Describing Patterns459

24.3 Iterator.460

24.4 Software Factory461

24.5 Strategy.462

24.6 Singleton. 462

24.7 Composite. 463

24.8 Decorator. 465

24.9 The Double-Dispatching Pattern466

24.10Flyweight. 467

24.11Proxy.468

24.12Facade.469

24.13Observer.469

25 Re ection and Introspection 473

25.1 Mechanisms for Understanding. 473

25.1.1 Class Objects473

25.1.2 The Class Name as String475

25.1.3 Testing the Class of an Object475

25.1.4 Creating an Instance from a Class477

25.1.5 Testing if an Object Understands a Message 478

25.1.6 Class Behavior 478

25.2 Methods as Objects479

25.3 Mechanisms for Modi cation.480

25.3.1 Method Editing in Smalltalk. 480

25.3.2 Dynamic Class Loading in Java481

25.4 Metaclasses483

26 Distributed Objects 487

26.1 Addresses, Ports, and Sockets.488

26.2 A Simple Client/Server Program490

26.3 Multiple Clients. 493

26.4 Transmitting Objects over a Network. 498

26.5 Providing More Complexity.501

27 Implementation 505

27.1 Compilers and Interpreters.505

27.2 The Receiver as Argument506

27.3 Inherited Methods. 507

27.3.1 The Problem of Multiple Inheritance 508

27.3.2 The Slicing Problem.508

27.4 Overridden Methods509

27.4.1 Eliminating Virtual Calls and Inlining. 511

27.5 Name Encoding. 511

27.6 Dispatch Tables. 512

27.6.1 A Method Cache. 513

27.7 Bytecode Interpreters 514

27.8 Just-In-Time Compilation517

A Source for the Eight-Queens Puzzle 521

A.1 Eight-Queens in Apple Object Pascal. 521

A.2 Eight-Queens in C++. 524

A.3 Eight-Queens in Java526

A.4 Eight-Queens in Objective-C.529

A.5 Eight-Queens in Ruby 532

A.6 Eight-Queens in Smalltalk534

B Source for the Billiards Game 537

B.1 The Version without Inheritance537

B.2 The Version with Inheritance.545

C Source for the Solitaire Game 551

Glossary 563

Index 595