book

Design Patterns For Dummies®

Name: Design Patterns For Dummies®
Author: Steve Holzner Ph.D.
ISBN: 9780471798545

by Steve Holzner Ph.D.

May 2006

Beginner

308 pages

5h 30m

English

Wiley

Read now

Unlock full access

Copyright
About the Author
Dedication
Author’s Acknowledgments
Publisher’s Acknowledgments
00. Introduction
0.1. About This Book0.2. Foolish Assumptions0.3. Conventions Used in This Book0.4. How This Book Is Organized0.4.1. Part I: Getting to Know Patterns0.4.2. Part II: Becoming an OOP Master0.4.3. Part III: The Part of Tens0.5. Icons Used in This Book0.6. Where to Go from Here
1. Getting to Know Patterns
1. Congratulations, Your Problem Has Already Been Solved
1.1. Just Find the Pattern that Fits1.2. Enter the Gang of Four Book1.3. Getting Started: The Mediator Pattern1.4. Adapting to the Adapter Pattern1.5. Standing In for Other Objects with the Proxy Pattern1.6. Taking a Look at the Observer Pattern
2. Putting Plans into Action with the Strategy Pattern
2.1. Extending Object-Oriented Programming2.1.1. The big four OOP building blocks2.1.1.1. Abstraction is the good kind of breakdown2.1.1.2. Encapsulating all that junk2.1.1.3. Mighty polymorphism rangers2.1.1.4. Inheritance without the pesky taxes2.1.2. Composition versus inheritance: A first attempt at designing the new cars2.2. Handling Change with “has-a” Instead of “is-a”2.3. Drawing Up Your Plans2.3.1. Creating your algorithms2.3.2. Using your algorithms2.3.3. Selecting algorithms at runtime2.4. Making Your Move with the Strategy Pattern
3. Creating and Extending Objects with the Decorator and Factory Patterns
3.1. Closed for Modification, Open for Extension3.2. Enter the Decorator Pattern3.3. Putting the Decorator Pattern to Work3.3.1. Creating a decorator3.3.2. Adding a disk3.3.3. Adding a CD3.3.4. Adding a monitor3.3.5. Testing it out3.4. Improving the New Operator with the Factory Pattern3.5. Building Your First Factory3.5.1. Creating the factory3.5.2. Creating the abstract Connection class3.5.3. Creating the concrete connection classes3.5.4. Testing it out3.6. Creating a Factory the GoF Way3.6.1. Creating an abstract factory3.6.2. Creating a concrete factory3.6.3. Creating the secure connection classes3.6.4. Testing it out

4. Watch What’s Going On with the Observer and Chain of Responsibility Patterns
4.1. Notifying Observers with the Observer Pattern4.1.1. Creating a subject interface4.1.2. Creating an observer interface4.1.3. Creating a subject4.1.4. Creating observers4.1.5. Testing the Database observers4.2. Using Java’s Observer Interface and Observable Class4.2.1. Watching with the Observer interface4.2.2. Notifying with the Observable class4.2.3. Creating the Observable object4.2.4. Creating the Observer objects4.2.5. Testing the Observable code4.3. Using the Chain of Responsibility Pattern4.3.1. Creating a help interface4.3.2. Creating chainable objects4.3.3. Testing the Help system
5. From One to Many: The Singleton and Flyweight Patterns
5.1. Instantiating Just One Object with the Singleton Pattern5.1.1. Creating a Singleton-based database5.1.2. Testing the Singleton pattern5.1.3. Uh oh, don’t forget about multithreading5.1.4. Putting the synchronized solution to work5.1.5. Handling threading better5.1.6. Putting the pre-thread solution to work5.2. The Flyweight Pattern Makes One Look like Many5.2.1. Creating a student5.2.2. Testing the Flyweight pattern5.2.3. Handling threading better
2. Becoming an OOP Master
6. Fitting Round Pegs into Square Holes with the Adapter and Facade Patterns
6.1. The Adapter Scenario6.2. Fixing Connection Problems with Adapters6.2.1. Creating Ace objects6.2.2. Creating Acme objects6.2.3. Creating an Ace-to-Acme object adapter6.2.4. Testing the adapter6.2.5. Inheriting class adapters6.3. Simplifying Life with Facades6.3.1. Dealing with a difficult object6.3.2. Creating a simplifying facade6.3.3. Testing the facade
7. Mass Producing Objects with the Template Method and Builder Patterns
7.1. Creating the First Robot7.2. Creating Robots with the Template Method Pattern7.2.1. Creating robots by template7.2.2. Testing the creation of robots7.2.3. Built-in Template Methods in Java7.2.4. Adding a hook7.2.5. Testing the hook method7.3. Building Robots with the Builder Pattern7.3.1. The client rules7.3.2. Letting clients build robots7.3.3. Creating some buildable robots7.3.4. Testing the robot builder
8. Handling Collections with the Iterator and Composite Patterns
8.1. Accessing Objects with the Iterator Pattern8.1.1. Accessing your objects with an iterator8.1.2. Gathering the vice presidents into a collection8.1.3. Creating the iterator8.1.4. Iterating over vice presidents8.1.5. More fun with for/in8.2. Putting Together Composites8.2.1. It all starts with an abstract class8.2.2. Creating the vice president leaves8.2.3. Creating the division branches8.2.4. Building your corporation8.3. Tracking the Composite Pattern in the Wild
9. Getting Control of Your Objects with the State and Proxy Patterns
9.1. Getting the State of Your Union with the State Pattern9.1.1. Using methods to hold state9.1.2. Using objects to encapsulate state9.1.3. Creating the state objects9.1.4. Putting the rental automat to the test9.2. Standing In for Other Objects with Proxies9.2.1. Can you hear me now? Creating the automat server9.2.2. Anyone there? Creating the automat proxy9.2.3. Using the proxy to connect around the world
10. Coordinating Your Objects with the Command and Mediator Patterns
10.1. Taking Command with the Command Pattern10.1.1. Aiming at the target: Creating your receiver objects10.1.2. Be the boss: Creating your commands10.1.3. Getting your commands to actually do something: Creating the invoker10.1.4. Putting commands to the test10.1.5. Supporting undo10.1.6. Testing the undo10.2. Coordinating with the Mediator Pattern10.2.1. Designing the Rutabagas-R-Us site10.2.2. Connecting it all up with the mediator10.2.3. Testing the Rutabagas-R-Us site
3. The Part of Tens
11. Ten More Design Patterns
11.1. Creating a Factory Factory: The Abstract Factory Pattern11.2. Cloning when You Need It: The Prototype Pattern11.3. Decoupling Abstractions from Implementations with the Bridge Pattern11.4. Creating Your Own Language: The Interpreter Pattern11.5. Forget Me Not: The Memento Pattern11.6. The Visitor Stops In for a Moment11.7. Going in Circles with Circular Buffers11.8. Doing Your Magic Off-Screen with the Double Buffer Pattern11.9. Getting Multiple-Use Objects Out of the Recycle Bin Design Pattern11.10. Entering the Big Time with the Model/View/Controller Pattern
12. Ten Easy Steps to Create Your Own Patterns
12.1. Following the Pattern Catalog Style12.2. Introducing the Veto Pattern12.2.1. Intent12.2.2. Motivation12.2.3. Applicability12.2.4. Structure12.2.5. Participants12.2.6. Collaborations12.2.7. Consequences12.2.8. Implementation/Sample Code12.2.9. Known Uses12.2.10. Related Patterns12.3. Getting Your Pattern into a Pattern Catalog
A. Design Patterns For Dummies®
A.1. The 23 Gang of Four Design PatternsA.1.1. The Strategy design patternA.1.2. The Decorator design patternA.1.3. The Factory Method design patternA.1.4. The Observer design patternA.1.5. The Chain of Responsibility design patternA.1.6. The Singleton design patternA.1.7. The Flyweight design patternA.1.8. The Adapter design patternA.1.9. The Facade design patternA.1.10. The Template design patternA.1.11. The Builder design patternA.1.12. The Iterator design patternA.1.13. The Composite design patternA.1.14. The Command design patternA.1.15. The Mediator design patternA.1.16. The State design patternA.1.17. The Proxy design patternA.1.18. The Abstract Factory design patternA.1.19. The Prototype design patternA.1.20. The Bridge design patternA.1.21. The Interpreter design patternA.1.22. The Memento design patternA.1.23. The Visitor design pattern

Content preview from Design Patterns For Dummies®

Appendix A. Design Patterns For Dummies^®

The 23 Gang of Four Design Patterns

Here are the original 23 Gang of Four design patterns (from Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley Professional Computing Series, by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides).

The Strategy design pattern

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

The Decorator design pattern

Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

The Factory Method design pattern

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

The Observer design pattern

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

The Chain of Responsibility design pattern

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

The Singleton design ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Design Patterns in Java™, Second Edition

Publisher Resources

ISBN: 9780471798545Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills