Register your product to gain access to bonus material or receive a coupon.
Applied Java Patterns
- By Stephen Stelting, Olaf Maassen
- Published Dec 26, 2001 by Pearson.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2002
- Dimensions: 7" x 9-1/4"
- Pages: 608
- Edition: 1st
- Book
- ISBN-10: 0-13-093538-7
- ISBN-13: 978-0-13-093538-0
Increasingly, Java developers are recognizing the value of patterns in helping to build more robust, effective software systems -- but most books on patterns are either generic or focused on other languages. Now, the creators of Sun's own course on Java patterns have written the definitive book for working developers. Replete with working code, this book offers practical help with all types of patterns, in every facet of development -- from individual classes to overall system architecture. First, the authors introduce the fundamentals of patterns, presenting a high-level overview of how they can be used most effectively in Java development, and introducing each key type of pattern: creational, behavioral, and structural. Next, they present specific techniques for using patterns with core Java APIs (including security, event, JavaBeans, and Swing APIs); and in advanced distributed development with JDBC, RMI, CORBA, JNDI, and JavaSpaces. The book concludes with detailed coverage of pattern use in enterprise systems built with servlets, JSP, and other J2EE infrastructure technologies.
Downloads
Downloads
As an aid to your work with Applied Java Patterns, we are making available for download the book's source code and figures.
Source Code
For your convenience, you can download the complete set of code examples from the book in a compressed archive. The code is available in three compression formats:
You may also wish to download the source code updates. See Updates for more detail.
Figures
You can download .zip archives of images related to the code examples in the book via the links below.
Sample Content
Online Sample Chapter
Creational Patterns: Creating Objects in an OO System
Table of Contents
Preface.
Why We Wrote This Book. What This Book Is About. Who Should Read This Book? Conventions Used. How This Book Is Organized. How to Use This Book. Companion Web Site. Acknowledgments.
Introduction.
Why Patterns? History of the Patterns Movement. Basic Concepts in Patterns. Software Abstraction and Reuse. Summary.
COMMONLY USED PATTERNS.
1. Creational Patterns.Introduction to Creational Patterns. Abstract Factory. Builder. Factory Method. Prototype. Singleton.
2. Behavioral Patterns.Introduction to Behavioral Patterns. Chain of Responsibility. Command. Interpreter. Iterator. Mediator. Memento. Observer. State. Strategy. Visitor. Template Method.
3. Structural Patterns.Introduction to Structural Patterns. Adapter. Bridge. Composite. Decorator. Façade. Flyweight. Half-Object Plus Protocol (HOPP). Proxy.
4. System Patterns.Introduction to System Patterns. Model-View-Controller (MVC). Session. Worker Thread. Callback. Successive Update. Router. Transaction.
II. PATTERNS IN THE JAVA PROGRAMMING LANGUAGE.
5. Introduction to Java Programming Language Patterns.6. Java Core APIs.
Event Handling. JavaBeans. AWT and Swing — The Graphical User Interface APIs. Collections Framework. Input-Output (I/O). Reflection.
7. Distributed Technologies.Java Naming and Directory Interface (JNDI). JDBC. RMI. CORBA.
8. Jini and J2EE Architectures.Jini. Java 2, Enterprise Edition (J2EE). Servlets and JSPs. Enterprise JavaBeans.
Appendix A: Full Code Examples.System Requirements. Creational Pattern Code Examples. Abstract Factory. Builder. Factory Method. Prototype. Singleton. Chain of Responsibility. Command. Interpreter. Iterator. Mediator. Memento. Observer. State. Strategy. Visitor. Template Method. Adapter. Bridge. Composite. Decorator. Façade. Flyweight. Half-Object Plus Protocol (HOPP). Proxy. Model-View-Controller (MVC). Session. Worker Thread. Callback. Successive Update. Router. Transaction.
Appendix B: Bibliography.Index.
Preface
Preface
Why We Wrote This BookDuring the many Java programming language courses we teach, we have found that only a few programmers know what design patterns are when asked. About one in ten is able to name a few patterns off the top of his or her head. Of course, the concepts behind the patterns are familiar to many programmers. When we demonstrate patterns in the classroom, developers know and recognize them.
We decided to create a pattern catalog for the Java programming language developers who understand at a basic level why patterns are a good idea, and are interested in applying them, but want a practical, hands-on guide to just how and why to use each individual pattern. We've kept the book casual and frank in tone, and included full working Java code examples for each.
We will have succeeded when you complete this book having not only learned about design patterns and the Java programming language, but having had fun reading it, as well.
What This Book Is AboutThis book will teach you the essential design patterns and how you can use them in your Java application. Furthermore, this book will show you where patterns are used in Java technology APIs and why they were used.
Who Should Read This BookThis book is intended for experienced Java programmers who want to build better applications. You should be comfortable with the Java programming language and be familiar with most of the basic Java APIs. Some knowledge of UML is useful, but not required. We recommend UML Distilled by Martin Fowler as a UML reference.
How This Book Is OrganizedThis book is divided into two parts. Part I, "Commonly Used Patterns," is organized like a pattern catalogue, reference-style.
Chapter 1: "Creational Patterns" on page 3 discusses patterns that create objects: Abstract Factory, Builder, Factory Method, Prototype, and Singleton.
Chapter 2: "Behavioral Patterns" on page 39 is focussed on the patterns that can determine the behavior of your object model: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor.
Chapter 3: "Structural Patterns" on page 139 describes patterns that can bring structure to your application and has the following patterns: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, HOPP, and Proxy.
Chapter 4: "System Patterns" on page 205 describes the patterns that help you build better architectures: Callback, Router, MVC, Session, Successive Update, Transaction, and Worker Thread.
Part II, "Patterns in the Java Programming Language," presents many of the Java APIs and shows the use of patterns in those API and their benefit.
Chapter 6: "Java Core APIs" on page 279 provides an overview in the familiar core APIs like Event Handling, JavaBeansTM, AWT and Swing, Collections, Input/Output, and Reflection.
Chapter 7: "Distributed Technologies" on page 303 describes selected distributed APIs and how patterns are used: JNDI, JDBC, RMI, and CORBA.
Chapter 8: "Jini and J2EE Architectures" on page 317 focuses on the two complementary frameworks Jini and J2EE. J2EE is further divided into Servlets, JSP and EJB technologies.
How to Use This BookThere are several ways to read this book. You could start at page one and read from cover to cover. However, we recommend you start with some of the easier patterns: Factory Method, Singleton, Observer, and Composite. Work your way through the book using those as starting points for your exploration. Alternatively, you might want to turn to sections in Part II first. Find an API you are familiar with and start looking for patterns there.
You can read the patterns in any order you feel most comfortable with. Later, you can use this book as a reference to refresh your memory when you want to put your knowledge of patterns into practice.
Companion Web SiteThis book has a companion Web site to provide you with updates and other material: it is located at http://www.phptr.com/appliedjavapatterns
Updates
Updates & Corrections
Below you will find the current errata list pertaining to the code examples in the book. You can download all of the code updates in a .zip archive.
Chapter 3
Composite
p. 163, Example 3.10: Deliverable.java required (Composite)
p. 164, Example 3.12: Project.java incorrectly repeated. DELETE THIS.
Appendix
Singleton
p. 363, Example A.31: RunPattern.java required.
Visitor
p. 439, Example A.127: DataRetriever.java required.
p. 439, Example A.128: RunPattern.java required.
Adapter
p. 447, Example A.137: RunPattern.java required.
Composite
p. 453, Example A.145: Deliverable.java required.
p. 454, Example A.147: Project.java.
MVC
p. 506, Example A.204: RunPattern.java required.