《Design Patterns in Java》Steve John Metsker - 英文第2版

需积分: 9 65 浏览量更新于2024-07-26 收藏 4.68MB PDF 举报

"这是一本由Steve John Metsker编写的英文版《Java设计模式》第二版，专注于介绍如何在Java编程中应用设计模式，以解决实际问题。这本书属于Software Patterns Series，旨在提供对软件开发人员有持久价值的模式文献。系列主编是John M. Vlissides，该系列书籍关注于软件开发、组织管理和用户使用中的普遍问题，并提炼出可立即应用的通用解决方案。" 设计模式是一种在软件工程中广泛采用的方法，它记录了在特定上下文中反复出现的问题及其解决方案。这些模式源于实践者的经验，而非理论或猜测，因此具有很强的相关性和影响力。它们可以改变开发人员的工作方式，使代码更易于理解和维护，提高软件的可扩展性和可重用性。在Java设计模式中，读者将接触到各种经典的设计模式，如单例模式（Singleton）、工厂模式（Factory）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）、观察者模式（Observer）、装饰器模式（Decorator）、适配器模式（Adapter）、桥接模式（Bridge）、代理模式（Proxy）、策略模式（Strategy）、命令模式（Command）、模板方法模式（Template Method）等。每种模式都针对特定的问题场景，提供了可复用的解决方案。例如，单例模式确保一个类只有一个实例，并提供一个全局访问点，常用于配置管理或线程池等场景。工厂模式则用于创建对象，通过抽象出创建过程，使得客户端代码与具体的产品实现解耦。建造者模式在创建复杂对象时更为灵活，允许逐步构建对象的各个部分。观察者模式允许对象之间建立一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。此外，设计模式还强调了面向对象设计的原则，如开闭原则（Open-Closed Principle）、里氏替换原则（Liskov Substitution Principle）、依赖倒置原则（Dependency Inversion Principle）、单一职责原则（Single Responsibility Principle）和接口隔离原则（Interface Segregation Principle）。这些原则指导我们写出高质量、可维护的代码。《Java设计模式》第二版可能会深入探讨每个模式的优缺点、适用场景以及如何在实际项目中正确地使用。书中可能还会包含实例代码，帮助读者更好地理解并掌握这些模式。通过阅读此书，Java开发者能够提升他们的设计能力和代码质量，从而构建更加健壮、可扩展的系统。这本书作为Software Patterns Series的一部分，不仅提供了丰富的设计模式知识，还展示了如何在实际Java开发中应用这些模式，以实现更高效、更具可维护性的软件解决方案。

ptg

INTRODUCTION

THIS BOOK COVERS the same set of techniques as the classic book

Design Patterns, written by Erich Gamma, Richard Helm, Ralph

Johnson, and John Vlissides [Gamma et al. 1995] and provides exam-

ples in a Java setting. This book also includes many “challenges”—

exercises designed to help you strengthen your ability to apply design

patterns in your own programs.

This book is for developers who know Java and who want to

improve their skills as designers.

Why Patterns?

A pattern is a way of doing something: a way of pursuing an intent, a

technique. The idea of capturing effective techniques applies to many

endeavors: making food, ﬁreworks, software, and other crafts. In any

new craft that is starting to mature, the people working on it will

begin to ﬁnd common, effective methods for achieving their aims

and solving problems in various contexts. The community of people

who practice a craft usually invent jargon that helps them talk about

their craft. Some of this jargon will refer to patterns, or established

techniques for achieving certain aims. As a craft and its jargon grows,

writers begin to play an important role. Writers document a craft’s

patterns, helping to standardize the jargon and to publicize effective

techniques.

Christopher Alexander was one of the ﬁrst writers to encapsulate a

craft’s best practices by documenting its patterns. His work relates to

architecture—of buildings, not software. In A Pattern Language: Towns,

Buildings Construction (Alexander, Ishikouwa, and Silverstein 1977),

Alexander provides patterns for architecting successful buildings and

towns. His writing is powerful and has inﬂuenced the software com-

munity, partially because of the way he looks at intent.

ptg

2 Chapter 1 • Introduction

You might think that the intent of architectural patterns would be

something like “to design buildings.” But Alexander makes it clear

that the intent of architectural patterns is to serve and inspire the

people who will occupy buildings and towns. Alexander’s work

showed that patterns are an excellent way to capture and convey the

wisdom of a craft. He also established that properly perceiving and

documenting the intent of a craft is a critical, philosophical, and elu-

sive challenge.

The software community has resonated with the patterns approach

and has created many books that document patterns of software

development. These books record best practices for software process,

software analysis, high-level architecture, and class-level design. New

pattern books appear every year. If you are choosing a book to read

about patterns, you should spend some time reading reviews of avail-

able books and try to select the book that will help you the most.

Why Design Patterns?

A design pattern is a pattern—a way to pursue an intent—that uses

classes and their methods in an object-oriented language. Developers

often start thinking about design after learning a programming lan-

guage and writing code for a while. You might notice that someone

else’s code seems simpler and works better than yours does, and you

might wonder how that developer achieves such simplicity. Design

patterns are a level up from code and typically show how to achieve a

goal using a few classes. A pattern represents an idea, not a particular

implementation.

Other people have discovered how to program effectively in object-

oriented languages. If you want to become a powerful Java program-

mer, you should study design patterns, especially those in this book—

the same patterns that Design Patterns explains.

Design Patterns describes 23 design patterns. Many other books on

design patterns have followed, so there are at least 100 design pat-

terns worth knowing. The 23 design patterns that Gamma, Helm,

Johnson, and Vlissides placed in Design Patterns are probably not

absolutely the most useful 23 design patterns to know. On the other

hand, these patterns are near the top of the list. The authors of Design

ptg

4 Chapter 1 • Introduction

UML

Where this book’s challenges (exercises) have solutions in code, this

book uses Java. But many of the challenges ask you to draw a diagram

of how classes, packages, and other elements relate. You can use any

notation you like, but this book uses Uniﬁed Modeling Language

(UML) notation. Even if you are familiar with UML, it is a good idea

to have a reference handy. Two good choices are The Uniﬁed Modeling

Language User Guide [Booch, Rumbaugh, and Jacobsen 1999], and

UML Distilled [Fowler with Scott 2003]. The bare minimum of UML

knowledge that you need for this book is provided in “Appendix D:

UML at a Glance” on page 431.

Challenges

No matter how much you read about doing something, you won’t

feel as though you know it until you do it. This is true partially

because until you exercise the knowledge you gain from a book, you

won’t encounter subtleties, and you won’t grapple with alternative

approaches. You won’t feel conﬁdent about design patterns until you

apply them to some real challenges.

The problem with learning through experience is that you can do

damage as you learn. You can’t apply patterns in production code

before you are conﬁdent in your own skills. But you need to start

applying patterns to gain conﬁdence. What a conundrum! The solu-

tion is to practice on example problems, where mistakes are valuable

but painless.

Each chapter in this book begins with a short introduction and then

sets up a series of challenges for you to solve. After you come up

with a solution, you can compare your solution with one given in

Solutions, page 347. The solution in the book may take a different

slant from your solution or may provide you with some other

insight.

You probably can’t go overboard in how hard you work to come up

with answers to the challenges in this book. If you consult other

books, work with a colleague, and write sample code to check out

your solution, terriﬁc! You will not regret investing your time and

energy in learning how to apply design patterns.

ptg

The Organization of This Book 5

A danger lurks in the solutions that this book provides. If you ﬂip to

the solution immediately after reading a challenge, you will not gain

much from this book. The solutions in this book won’t do you any

good if you don’t ﬁrst create your own solutions.

The Organization of This Book

There are many ways to organize and categorize patterns. You might

organize them according to similarities in structure, or you might fol-

low the order in Design Patterns. But the most important aspect of any

pattern is its intent, that is, the potential value of applying the pat-

tern. This book organizes the 23 patterns of Design Patterns according

to their intent.

Having decided to organize patterns by intent raises the question of

how to categorize intent. This book adopts the notion that the intent

of a design pattern is usually easily expressed as the need to go

beyond the ordinary facilities that are built into Java. For example,

Java has plentiful support for deﬁning the interfaces that a class

implements. But if you have a class with the “wrong” interface and

need to somehow make it meet the needs of a client, you may decide

to apply the ADAPTER pattern. The intent of the ADAPTER pattern is to

help you go beyond the interface facilities built into Java.

This book places design pattern intent in ﬁve categories, as follows:

1. Interfaces

2. Responsibility

3. Construction

4. Operations

5. Extensions

These ﬁve categories account for the ﬁve parts of this book. Each part

begins with a chapter that discusses and presents challenges related to

features built into Java. For example, Part I begins with a chapter on

ordinary Java interfaces. This chapter will challenge your understand-

ing of the Java interface construct, especially in comparison to

abstract classes. The remaining chapters of Part I address patterns

whose primary intent involves the deﬁnition of an interface, the set

of methods that a client can call from a service provider. Each of these

剩余477页未读，继续阅读

「已注销」

粉丝: 0
资源: 3

《Design Patterns in Java》Steve John Metsker - 英文第2版

23种JAVA设计模式经典（推荐必读）.pdf

java设计模式电子书

[Java设计模式(第2版)(Design.Patterns.in.Java).John.Metsker

适合C语言设计模式的书籍

Java 设计模式 第二版

java设计模式(第二版)(含源代码)

dpij:史蒂夫·梅茨克（Steve Metsker）和比尔·韦克（Bill Wake）编写的“ Java设计模式”源代码-java source code

java design pattern

Design Patterns Workbook 英文版 (pdf)

基于java的网上商城开发开题报告.pdf

最新资源

Java 设计模式第二版