设计模式：可复用面向对象软件的核心元素

需积分: 16 115 浏览量更新于2024-07-17 收藏 1.1MB DOCX 举报

"Design Patterns: Elements of Reusable Object-Oriented Software 是一本经典著作，主要讨论了面向对象设计模式，这些模式在不同的软件工程背景下已被证明具有价值。这本书自首次发布以来，受到了广泛的认可和欢迎，许多软件工程师表示设计模式帮助他们设计和构建更优秀的系统。同时，这本书激发了许多人编写自己的模式，促进了模式库的不断增长。读者反馈中，人们普遍认为这本书非常适合以超文本形式呈现，因为书中包含大量交叉引用，电脑可以方便地追踪这些引用，与软件开发过程中的非线性思考方式相吻合。" 本书的核心内容围绕23种经典的设计模式展开，这些模式被分为三类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。创建型模式关注对象的创建，如单例模式（Singleton）、工厂方法模式（Factory Method）和抽象工厂模式（Abstract Factory），它们旨在提供对对象创建过程的抽象，使得系统独立于如何创建、组合和表示对象。结构型模式涉及如何将类或对象组合成更大的结构，如适配器模式（Adapter）、装饰器模式（Decorator）和代理模式（Proxy），这些模式使不同组件能够协同工作。行为型模式关注对象之间的通信和责任分配，如观察者模式（Observer）、命令模式（Command）和策略模式（Strategy），它们有助于实现灵活的行为设计。设计模式不仅仅是代码模板，它们代表了解决常见软件设计问题的最佳实践。通过使用设计模式，开发者可以更有效地沟通设计意图，提高代码的可读性和可维护性，减少重复工作，并促进代码的复用。此外，设计模式还可以帮助团队遵循良好的软件工程原则，如开闭原则（Open-Closed Principle）、里氏替换原则（Liskov Substitution Principle）和依赖倒置原则（Dependency Inversion Principle）等。书中每一章都详细介绍了每个模式的动机、结构、参与者、协作以及模式的优缺点。此外，还包括了模式的应用示例和与其他模式的关系。作者们强调，理解设计模式的关键在于理解和识别何时以及如何应用它们，而不仅仅是机械地复制代码。《设计模式：可重用面向对象软件的基础》不仅是一本关于具体模式的参考书，还是一本关于如何思考和设计面向对象系统的指南。它鼓励软件工程师们在面对复杂性和变化时，采用经过验证的解决方案，从而提升软件的质量和可扩展性。

Design Patterns: Elements of Reusable Object-Oriented Software

1. 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.

Design Patterns: Elements of Reusable Object-Oriented Software

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.

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]. 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:

Design Patterns: Elements of Reusable Object-Oriented Software

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

剩余63页未读，继续阅读

一纸传说

粉丝: 23
资源: 2

设计模式：可复用面向对象软件的核心元素

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

Design Patterns Elements of Reusable Object-Oriented Software

Design Patterns - Elements of Reusable Object-Oriented Software.rar

design patterns elements of reusable object-oriented software.pdf

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

最新资源