面向对象软件复用的关键设计模式详解

5星 · 超过95%的资源需积分: 10 152 浏览量更新于2024-08-01 收藏 2.08MB PDF 举报

《设计模式：可复用面向对象软件元素》是一本经典的计算机科学著作，由Erich Gamma等人合著，由Addison Wesley出版。这本书主要关注于软件开发中的设计模式，这是一种在解决常见问题时可以重用的、经过验证的最佳实践和解决方案。它不仅提供了一套标准化的设计语言，还帮助开发者理解和应用这些模式来优化代码结构，提高软件的可维护性和扩展性。本书分为两大部分，首先介绍了设计模式的基本概念和用途。作者解释了什么是设计模式，以及它们如何在诸如Smalltalk的Model-View-Controller（MVC）架构中体现。设计模式的描述是清晰和直观的，强调了它们在软件设计中的作用，包括解决问题的方式，以及如何选择和应用恰当的模式。第二部分深入探讨了两类核心的设计模式：创建型（Creational）和结构型（Structural）模式。创建型模式关注对象的创建过程，包括抽象工厂（Abstract Factory）、构建器（Builder）、工厂方法（Factory Method）、原型（Prototype）和单例（Singleton）。这些模式帮助处理对象实例化、配置和行为的灵活性问题。结构型模式则侧重于对象之间的关系和组织，如适配器（Adapter）、桥接（Bridge）、组合（Composite）、装饰器（Decorator）、外观（Facade）、享元（Flyweight）和代理（Proxy）。这些模式处理的是对象之间的依赖和耦合，以实现模块化、松耦合的系统。书中通过一个文档编辑器的设计案例，展示了如何应用这些模式来解决实际的开发问题，包括文档结构管理、格式化、用户界面增强、跨平台兼容性和用户操作支持等。此外，还包括了拼写检查和自动断句功能的实现，进一步说明了设计模式在复杂系统中的实用性。总结来说，《设计模式：可复用对象导向软件元素》是一本重要的参考书籍，对于任何致力于软件工程和面向对象设计的专业人士而言，理解并掌握这些设计模式至关重要，因为它们能够提升软件开发的效率，确保代码的可读性和可维护性，从而促进团队协作和项目成功。

Introduction

Designing object-oriented software is hard, and designing reusable object-oriented software is even harder.

You must find pertinent objects, factor them into classes at the right granularity, define class interfaces and

inheritance hierarchies, and establish key relationships among them. Your design should be specific to the

problem at hand but also general enough to address future problems and requirements. You also want to

avoid redesign, or at least minimize it. Experienced object-oriented designers will tell you that a reusable

and flexible design is difficult if not impossible to get "right" the first time. Before a design is finished, they

usually try to reuse it several times, modifying it each time.

Yet experienced object-oriented designers do make good designs. Meanwhile new designers are

overwhelmed by the options available and tend to fall back on non-object-oriented techniques they've used

before. It takes a long time for novices to learn what good object-oriented design is all about. Experienced

designers evidently know something inexperienced ones don't. What is it?

One thing expert designers know not to do is solve every problem from first principles. Rather, they reuse

solutions that have worked for them in the past. When they find a good solution, they use it again and again.

Such experience is part of what makes them experts. Consequently, you'll find recurring patterns of classes

and communicating objects in many object-oriented systems. These patterns solve specific design problems

and make object-oriented designs more flexible, elegant, and ultimately reusable. They help designers reuse

successful designs by basing new designs on prior experience. A designer who is familiar with such patterns

can apply them immediately to design problems without having to rediscover them.

An analogy will help illustrate the point. Novelists and playwrights rarely design their plots from scratch.

Instead, they follow patterns like "Tragically Flawed Hero" (Macbeth, Hamlet, etc.) or "The Romantic

Novel" (countless romance novels). In the same way, object-oriented designers follow patterns like

"represent states with objects" and "decorate objects so you can easily add/remove features." Once you know

the pattern, a lot of design decisions follow automatically.

We all know the value of design experience. How many times have you had design déjà-vu—that feeling

that you've solved a problem before but not knowing exactly where or how? If you could remember the

details of the previous problem and how you solved it, then you could reuse the experience instead of

rediscovering it. However, we don't do a good job of recording experience in software design for others to

use.

The purpose of this book is to record experience in designing object-oriented software as

design patterns.

Each design pattern systematically names, explains, and evaluates an important and recurring design in

object-oriented systems. Our goal is to capture design experience in a form that people can use effectively.

To this end we have documented some of the most important design patterns and present them as a catalog.

Design patterns make it easier to reuse successful designs and architectures. Expressing proven techniques

as design patterns makes them more accessible to developers of new systems. Design patterns help you

choose design alternatives that make a system reusable and avoid alternatives that compromise reusability.

Design patterns can even improve the documentation and maintenance of existing systems by furnishing an

explicit specification of class and object interactions and their underlying intent. Put simply, design patterns

help a designer get a design "right" faster.

None of the design patterns in this book describes new or unproven designs. We have included only designs

that have been applied more than once in different systems. Most of these designs have never been

documented before. They are either part of the folklore of the object-oriented community or are elements of

some successful object-oriented systems—neither of which is easy for novice designers to learn from. So

although these designs aren't new, we capture them in a new and accessible way: as a catalog of design

patterns having a consistent format.

http://lci.cs.ubbcluj.ro/~raduking/Books/Design%20Patterns/chap1fs.htm (1 of 24) [21/08/2002 19:04:16]

Introduction

Despite the book's size, the design patterns in it capture only a fraction of what an expert might know. It

doesn't have any patterns dealing with concurrency or distributed programming or real-time programming. It

doesn't have any application domain-specific patterns. It doesn't tell you how to build user interfaces, how to

write device drivers, or how to use an object-oriented database. Each of these areas has its own patterns, and

it would be worthwhile for someone to catalog those too.

What is a Design Pattern?

Christopher Alexander says, "Each pattern describes a problem which occurs over and over again in our

environment, and then describes the core of the solution to that problem, in such a way that you can use this

solution a million times over, without ever doing it the same way twice" [

AIS+77, page x]. Even though

Alexander was talking about patterns in buildings and towns, what he says is true about object-oriented

design patterns. Our solutions are expressed in terms of objects and interfaces instead of walls and doors, but

at the core of both kinds of patterns is a solution to a problem in a context.

In general, a pattern has four essential elements:

1. The pattern name is a handle we can use to describe a design problem, its solutions, and

consequences in a word or two. Naming a pattern immediately increases our design vocabulary. It

lets us design at a higher level of abstraction. Having a vocabulary for patterns lets us talk about them

with our colleagues, in our documentation, and even to ourselves. It makes it easier to think about

designs and to communicate them and their trade-offs to others. Finding good names has been one of

the hardest parts of developing our catalog.

2. The problem describes when to apply the pattern. It explains the problem and its context. It might

describe specific design problems such as how to represent algorithms as objects. It might describe

class or object structures that are symptomatic of an inflexible design. Sometimes the problem will

include a list of conditions that must be met before it makes sense to apply the pattern.

3. The solution describes the elements that make up the design, their relationships, responsibilities, and

collaborations. The solution doesn't describe a particular concrete design or implementation, because

a pattern is like a template that can be applied in many different situations. Instead, the pattern

provides an abstract description of a design problem and how a general arrangement of elements

(classes and objects in our case) solves it.

4. The consequences are the results and trade-offs of applying the pattern. Though consequences are

often unvoiced when we describe design decisions, they are critical for evaluating design alternatives

and for understanding the costs and benefits of applying the pattern. The consequences for software

often concern space and time trade-offs. They may address language and implementation issues as

well. Since reuse is often a factor in object-oriented design, the consequences of a pattern include its

impact on a system's flexibility, extensibility, or portability. Listing these consequences explicitly

helps you understand and evaluate them.

Point of view affects one's interpretation of what is and isn't a pattern. One person's pattern can be another

person's primitive building block. For this book we have concentrated on patterns at a certain level of

abstraction. Design patterns are not about designs such as linked lists and hash tables that can be encoded in

classes and reused as is. Nor are they complex, domain-specific designs for an entire application or

subsystem. The design patterns in this book are descriptions of communicating objects and classes that are

customized to solve a general design problem in a particular context.

A design pattern names, abstracts, and identifies the key aspects of a common design structure that make it

useful for creating a reusable object-oriented design. The design pattern identifies the participating classes

and instances, their roles and collaborations, and the distribution of responsibilities. Each design pattern

focuses on a particular object-oriented design problem or issue. It describes when it applies, whether it can

be applied in view of other design constraints, and the consequences and trade-offs of its use. Since we must

http://lci.cs.ubbcluj.ro/~raduking/Books/Design%20Patterns/chap1fs.htm (2 of 24) [21/08/2002 19:04:16]

Introduction

eventually implement our designs, a design pattern also provides sample C++ and (sometimes) Smalltalk

code to illustrate an implementation.

Although design patterns describe object-oriented designs, they are based on practical solutions that have

been implemented in mainstream object-oriented programming languages like Smalltalk and C++ rather

than procedural languages (Pascal, C, Ada) or more dynamic object-oriented languages (CLOS, Dylan,

Self). We chose Smalltalk and C++ for pragmatic reasons: Our day-to-day experience has been in these

languages, and they are increasingly popular.

The choice of programming language is important because it influences one's point of view. Our patterns

assume Smalltalk/C++-level language features, and that choice determines what can and cannot be

implemented easily. If we assumed procedural languages, we might have included design patterns called

"Inheritance," "Encapsulation," and "Polymorphism." Similarly, some of our patterns are supported directly

by the less common object-oriented languages. CLOS has multi-methods, for example, which lessen the

need for a pattern such as

Visitor (page 331). In fact, there are enough differences between Smalltalk and

C++ to mean that some patterns can be expressed more easily in one language than the other. (See

Iterator

(257) for an example.)

Design Patterns in Smalltalk MVC

The Model/View/Controller (MVC) triad of classes [

KP88] is used to build user interfaces in Smalltalk-80.

Looking at the design patterns inside MVC should help you see what we mean by the term "pattern."

MVC consists of three kinds of objects. The Model is the application object, the View is its screen

presentation, and the Controller defines the way the user interface reacts to user input. Before MVC, user

interface designs tended to lump these objects together. MVC decouples them to increase flexibility and

reuse.

MVC decouples views and models by establishing a subscribe/notify protocol between them. A view must

ensure that its appearance reflects the state of the model. Whenever the model's data changes, the model

notifies views that depend on it. In response, each view gets an opportunity to update itself. This approach

lets you attach multiple views to a model to provide different presentations. You can also create new views

for a model without rewriting it.

The following diagram shows a model and three views. (We've left out the controllers for simplicity.) The

model contains some data values, and the views defining a spreadsheet, histogram, and pie chart display

these data in various ways. The model communicates with its views when its values change, and the views

communicate with the model to access these values.

http://lci.cs.ubbcluj.ro/~raduking/Books/Design%20Patterns/chap1fs.htm (3 of 24) [21/08/2002 19:04:16]

Introduction

Taken at face value, this example reflects a design that decouples views from models. But the design is

applicable to a more general problem: decoupling objects so that changes to one can affect any number of

others without requiring the changed object to know details of the others. This more general design is

described by the

Observer (page 293) design pattern.

Another feature of MVC is that views can be nested. For example, a control panel of buttons might be

implemented as a complex view containing nested button views. The user interface for an object inspector

can consist of nested views that may be reused in a debugger. MVC supports nested views with the

CompositeView class, a subclass of View. CompositeView objects act just like View objects; a composite

view can be used wherever a view can be used, but it also contains and manages nested views.

Again, we could think of this as a design that lets us treat a composite view just like we treat one of its

components. But the design is applicable to a more general problem, which occurs whenever we want to

group objects and treat the group like an individual object. This more general design is described by the

Composite (163) design pattern. It lets you create a class hierarchy in which some subclasses define

primitive objects (e.g., Button) and other classes define composite objects (CompositeView) that assemble

the primitives into more complex objects.

MVC also lets you change the way a view responds to user input without changing its visual presentation.

You might want to change the way it responds to the keyboard, for example, or have it use a pop-up menu

instead of command keys. MVC encapsulates the response mechanism in a Controller object. There is a

class hierarchy of controllers, making it easy to create a new controller as a variation on an existing one.

A view uses an instance of a Controller subclass to implement a particular response strategy; to implement a

different strategy, simply replace the instance with a different kind of controller. It's even possible to change

a view's controller at run-time to let the view change the way it responds to user input. For example, a view

can be disabled so that it doesn't accept input simply by giving it a controller that ignores input events.

The View-Controller relationship is an example of the

Strategy (315) design pattern. A Strategy is an object

that represents an algorithm. It's useful when you want to replace the algorithm either statically or

dynamically, when you have a lot of variants of the algorithm, or when the algorithm has complex data

http://lci.cs.ubbcluj.ro/~raduking/Books/Design%20Patterns/chap1fs.htm (4 of 24) [21/08/2002 19:04:16]

Introduction

structures that you want to encapsulate.

MVC uses other design patterns, such as

Factory Method (107) to specify the default controller class for a

view and

Decorator (175) to add scrolling to a view. But the main relationships in MVC are given by the

Observer, Composite, and Strategy design patterns.

Describing Design Patterns

How do we describe design patterns? Graphical notations, while important and useful, aren't sufficient. They

simply capture the end product of the design process as relationships between classes and objects. To reuse

the design, we must also record the decisions, alternatives, and trade-offs that led to it. Concrete examples

are important too, because they help you see the design in action.

We describe design patterns using a consistent format. Each pattern is divided into sections according to the

following template. The template lends a uniform structure to the information, making design patterns easier

to learn, compare, and use.

Pattern Name and Classification

The pattern's name conveys the essence of the pattern succinctly. A good name is vital, because it

will become part of your design vocabulary. The pattern's classification reflects the scheme we

introduce in

Section 1.5.

Intent

A short statement that answers the following questions: What does the design pattern do? What is its

rationale and intent? What particular design issue or problem does it address?

Also Known As

Other well-known names for the pattern, if any.

Motivation

A scenario that illustrates a design problem and how the class and object structures in the pattern

solve the problem. The scenario will help you understand the more abstract description of the pattern

that follows.

Applicability

What are the situations in which the design pattern can be applied? What are examples of poor

designs that the pattern can address? How can you recognize these situations?

Structure

A graphical representation of the classes in the pattern using a notation based on the Object Modeling

Technique (OMT) [

RBP+91]. We also use interaction diagrams [JCJO92, Boo94] to illustrate

sequences of requests and collaborations between objects.

Appendix B describes these notations in

detail.

Participants

The classes and/or objects participating in the design pattern and their responsibilities.

Collaborations

How the participants collaborate to carry out their responsibilities.

Consequences

How does the pattern support its objectives? What are the trade-offs and results of using the pattern?

What aspect of system structure does it let you vary independently?

Implementation

http://lci.cs.ubbcluj.ro/~raduking/Books/Design%20Patterns/chap1fs.htm (5 of 24) [21/08/2002 19:04:16]

剩余380页未读，继续阅读

asianboycn

粉丝: 0
资源: 1

面向对象软件复用的关键设计模式详解

design patterns elements of reusable object-oriented software.pdf

design patterns elements of reusable object-oriented software

Design Patterns Elements of Reusable Object-Oriented Software

design patterns elements of reusable object-oriented software.docx

Design Patterns Elements of Reusable Object-Oriented Software 英文版 (chm)

design patterns elements of reusable object-oriented software下载

Design Patterns - Elements of Reusable Object-Oriented Software - Gof

Design Patterns,Elements of Reusable Object-Oriented Software

Design_Patterns Elements of Reusable Object-Oriented Software

Design Patterns:Elements of Reusable Object-Oriented Software

最新资源