book

Head First Design Patterns

by Eric Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra

October 2004

Intermediate to advanced

692 pages

15h 18m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Dedication
Praise for Head First Design Patterns
More Praise for Head First Design Patterns
Praise for other books by Eric Freeman and Elisabeth Robson
Authors of Head First Design Patterns
Creators of the Head First series (and co-conspirators on this book)
How to Use This Book: Intro
Who is this book for?Who should probably back away from this book?We know what you’re thinking.And we know what your brain is thinking.Metacognition: thinking about thinkingHere’s what WE didHere’s what YOU can do to bend your brain into submissionRead MeTech ReviewersAcknowledgmentsEven more people
1. Intro to Design Patterns: Welcome to Design Patterns
It started with a simple SimUDuck appBut now we need the ducks to FLYBut something went horribly wrong...Joe thinks about inheritance...How about an interface?What would you do if you were Joe?The one constant in software developmentZeroing in on the problem...Separating what changes from what stays the sameDesigning the Duck BehaviorsImplementing the Duck BehaviorsIntegrating the Duck BehaviorMore integration...Testing the Duck codeSetting behavior dynamicallyThe Big Picture on encapsulated behaviorsHAS-A can be better than IS-ASpeaking of Design Patterns...Overheard at the local diner...Overheard in the next cubicle...The power of a shared pattern vocabularyHow do I use Design Patterns?Tools for your Design Toolbox
2. The Observer Pattern: Keeping your Objects in the know
The Weather Monitoring application overviewUnpacking the WeatherData classWhat do we know so far?Taking a first, misguided SWAG at the Weather StationWhat’s wrong with our implementation?Meet the Observer PatternPublishers + Subscribers = Observer PatternA day in the life of the Observer PatternFive-minute drama: a subject for observationTwo weeks later...The Observer Pattern definedThe Observer Pattern defined: the class diagramThe power of Loose CouplingCubicle conversationDesigning the Weather StationImplementing the Weather StationImplementing the Subject interface in WeatherDataNow, let’s build those display elementsPower up the Weather StationUsing Java’s built-in Observer PatternHow Java’s built-in Observer Pattern worksReworking the Weather Station with the built-in supportRunning the new codeThe dark side of java.util.ObservableOther places you’ll find the Observer Pattern in the JDKAnd the code...The updated code, using lambda expressionsTools for your Design Toolbox
3. The Decorator Pattern: Decorating Objects
Welcome to Starbuzz CoffeeThe Open-Closed PrincipleMeet the Decorator PatternConstructing a drink order with DecoratorsOkay, here’s what we know so far...The Decorator Pattern definedDecorating our BeveragesCubicle ConversationNew barista trainingWriting the Starbuzz codeCoding beveragesCoding condimentsServing some coffeesReal World Decorators: Java I/ODecorating the java.io classesWriting your own Java I/O DecoratorTest out your new Java I/O DecoratorGive it a spinTools for your Design Toolbox

4. The Factory Pattern: Baking with OO Goodness
Identifying the aspects that varyBut the pressure is on to add more pizza typesEncapsulating object creationBuilding a simple pizza factoryReworking the PizzaStore classThe Simple Factory definedFranchising the pizza storeWe’ve seen one approach...But you’d like a little more quality control...A framework for the pizza storeAllowing the subclasses to decideLet’s make a PizzaStoreDeclaring a factory methodLet’s see how it works: ordering pizzas with the pizza factory methodSo how do they order?Let’s check out how these pizzas are really made to order...We’re just missing one thing: PIZZA!Our PizzaStore isn’t going to be very popular without some pizzas, so let’s implement themNow we just need some concrete subclasses... how about defining New York and Chicago style cheese pizzas?You’ve waited long enough. Time for some pizzas!It’s finally time to meet the Factory Method PatternThe Creator classesThe Product classesAnother perspective: parallel class hierarchiesFactory Method Pattern definedA very dependent PizzaStoreLooking at object dependenciesThe Dependency Inversion PrincipleApplying the PrincipleInverting your thinking...A few guidelines to help you follow the Principle...Meanwhile, back at the PizzaStore...Ensuring consistency in your ingredientsFamilies of ingredients...Building the ingredient factoriesBuilding the New York ingredient factoryReworking the pizzas...Reworking the pizzas, continued...Revisiting our pizza storesWhat have we done?More pizza for Ethan and Joel...From here things change, because we are using an ingredient factoryAbstract Factory Pattern definedFactory Method and Abstract Factory comparedTools for your Design ToolboxA very dependent PizzaStore
5. The Singleton Pattern: One of a Kind Objects
The Little SingletonA small Socratic exercise in the style of The Little LisperDissecting the classic Singleton Pattern implementationThe Chocolate FactorySingleton Pattern definedHouston, Hershey, PA we have a problem...Dealing with multithreadingCan we improve multithreading?1. Do nothing if the performance of getInstance() isn’t critical to your application.2. Move to an eagerly created instance rather than a lazily created one.3. Use “double-checked locking” to reduce the use of synchronization in getInstance().Meanwhile, back at the Chocolate Factory...Congratulations!Tools for your Design Toolbox
6. The Command Pattern: Encapsulating Invocation
Free hardware! Let’s check out the Remote Control...Taking a look at the vendor classesCubicle ConversationMeanwhile, back at the Diner..., or, A brief introduction to the Command PatternLet’s study the interaction in a little more detail...The Objectville Diner roles and responsibilitiesFrom the Diner to the Command PatternOur first command objectUsing the command objectCreating a simple test to use the Remote ControlThe Command Pattern definedThe Command Pattern defined: the class diagramAssigning Commands to slotsImplementing the Remote ControlImplementing the CommandsPutting the Remote Control through its pacesNow, let’s check out the execution of our remote control test...Time to write that documentation...What are we doing?Time to QA that Undo button!Using state to implement UndoAdding Undo to the CeilingFan commandsGet ready to test the ceiling fanTesting the ceiling fan...Every remote needs a Party Mode!Using a macro commandThe Command Pattern means lots of command classesDo we really need all these command classes?Simplifying the Remote Control with lambda expressionsSimplifying even more with method referencesWhat if we need to do more than one thing in our lambda expression?Test the remote control with lambda expressionsCheck out the results of all those lambda expression commands...More uses of the Command Pattern: queuing requestsMore uses of the Command Pattern: logging requestsTools for your Design Toolbox
7. The Adapter and Facade Patterns: Being Adaptive
Adapters all around usObject-oriented adaptersIf it walks like a duck and quacks like a duck, then it must might be a duck turkey wrapped with a duck adapter...Test drive the adapterThe Adapter Pattern explainedHere’s how the Client uses the AdapterAdapter Pattern definedObject and class adaptersReal-world adaptersOld-world EnumeratorsNew-world IteratorsAnd today...Adapting an Enumeration to an IteratorDesigning the AdapterDealing with the remove() methodWriting the EnumerationIterator adapterAnd now for something different...Home Sweet Home TheaterWatching a movie (the hard way)Lights, Camera, Facade!Constructing your home theater facadeImplementing the simplified interfaceTime to watch a movie (the easy way)Facade Pattern definedThe Principle of Least KnowledgeHow NOT to Win Friends and Influence ObjectsKeeping your method calls in bounds...The Facade and the Principle of Least KnowledgeTools for your Design Toolbox
8. The Template Method Pattern: Encapsulating Algorithms
It’s time for some more caffeineWhipping up some coffee and tea classes (in Java)And now the Tea...Sir, may I abstract your Coffee, Tea?Taking the design further...Abstracting prepareRecipe()What have we done?Meet the Template MethodLet’s make some tea...What did the Template Method get us?Template Method Pattern definedHooked on Template Method...Using the hookLet’s run the Test DriveThe Hollywood PrincipleThe Hollywood Principle and Template MethodTemplate Methods in the WildSorting with Template MethodWe’ve got some ducks to sort...What is compareTo()?Comparing Ducks and DucksLet’s sort some DucksThe making of the sorting duck machineSwingin’ with FramesAppletsTools for your Design Toolbox
9. The Iterator and Composite Patterns: Well-Managed Collections
Breaking News: Objectville Diner and Objectville Pancake House MergeCheck out the Menu ItemsLou and Mel’s Menu implementationsWhat’s the problem with having two different menu representations?The Java-Enabled Waitress SpecificationWhat now?Can we encapsulate the iteration?Meet the Iterator PatternAdding an Iterator to DinerMenuReworking the Diner Menu with IteratorFixing up the Waitress codeTesting our codeHere’s the test run...What have we done so far?What we have so far...Making some improvements...Cleaning things up with java.util.IteratorWe are almost there...What does this get us?Iterator Pattern definedSingle ResponsibilityTaking a look at the Café MenuReworking the Café Menu codeAdding the Café Menu to the WaitressBreakfast, lunch AND dinnerHere’s the test run; check out the new dinner menu from the Café!What did we do?We decoupled the Waitress....... and we made the Waitress more extensibleBut there’s more!Iterators and CollectionsIs the Waitress ready for prime time?Just when we thought it was safe...What do we need?The Composite Pattern definedDesigning Menus with CompositeImplementing the Menu ComponentImplementing the Menu ItemImplementing the Composite MenuFixing the print() methodGetting ready for a test drive...Now for the test drive...Getting ready for a test drive...Flashback to IteratorThe Composite IteratorThe Null IteratorGive me the vegetarian menuThe magic of Iterator & Composite together...Tools for your Design Toolbox
10. The State Pattern: The State of Things
Jawva BreakersCubicle ConversationState machines 101Writing the codeIn-house testingYou knew it was coming... a change request!The messy STATE of things...The new designDefining the State interfaces and classesImplementing our State classesReworking the Gumball MachineNow, let’s look at the complete GumballMachine class...Implementing more statesLet’s take a look at what we’ve done so far...The State Pattern definedWe still need to finish the Gumball 1 in 10 gameFinishing the gameDemo for the CEO of Mighty Gumball, Inc.Sanity check...We almost forgot!Tools for your Design Toolbox
11. The Proxy Pattern: Controlling Object Access
Coding the MonitorTesting the MonitorThe role of the ‘remote proxy’Adding a remote proxy to the Gumball Machine monitoring codeRemote methods 101Java RMI, the Big PictureHow does the client get the stub object?Back to our GumballMachine remote proxyGetting the GumballMachine ready to be a remote serviceRegistering with the RMI registry...Now for the GumballMonitor client...Writing the Monitor test driveAnother demo for the CEO of Mighty Gumball...And now let’s put the monitor in the hands of the CEO. Hopefully, this time he’ll love itThe Proxy Pattern definedGet ready for Virtual ProxyRemote ProxyVirtual ProxyDisplaying CD coversDesigning the CD cover Virtual ProxyHow ImageProxy is going to workWriting the Image ProxyTesting the CD Cover ViewerThings to try...What did we do?Using the Java API’s Proxy to create a protection proxyMatchmaking in ObjectvilleThe PersonBean implementationFive-minute drama: protecting subjectsBig Picture: creating a Dynamic Proxy for the PersonBeanStep one: creating Invocation HandlersCreating Invocation Handlers continued...Step two: creating the Proxy class and instantiating the Proxy objectTesting the matchmaking serviceRunning the code...The Proxy ZooTools for your Design ToolboxThe code for the CD Cover Viewer
12. Compound Patterns: Patterns of Patterns
Working togetherDuck reunionWhat did we do?A duck’s eye view: the class diagramThe King of Compound PatternsIf Elvis were a compound pattern, his name would be Model-View-Controller, and he’d be singing a little song like this...Meet the Model-View-ControllerA closer look...Looking at MVC through patterns-colored glassesObserverStrategyCompositeUsing MVC to control the beat...Meet the Java DJ ViewThe controller is in the middle...Let’s not forget about the model underneath it all...Putting the pieces togetherBuilding the piecesLet’s check out the BeatModelInterface before looking at the implementationNow let’s have a look at the concrete BeatModel classThe ViewImplementing the ViewImplementing the View, continued...Now for the ControllerAnd here’s the implementation of the controllerPutting it all together...And now for a test run...Things to doExploring StrategyAdapting the ModelNow we’re ready for a HeartControllerAnd that’s it! Now it’s time for some test code...And now for a test run...Things to doMVC and the WebModel 2: DJ’ing from a cell phoneThe planStep one: the modelStep two: the controller servletNow we need a view...Putting Model 2 to the test...Things to doDesign Patterns and Model 2Model 2 is an adaptation of MVC to the WebObserverStrategyCompositeTools for your Design ToolboxExercise Solutions
13. Better Living with Patterns: Patterns in the Real World
Design Pattern definedLooking more closely at the Design Pattern definitionSo you wanna be a Design Patterns writerOrganizing Design PatternsPattern CategoriesThinking in PatternsKeep it simple (KISS)Design Patterns aren’t a magic bullet; in fact, they’re not even a bullet!You know you need a pattern when...Refactoring time is Patterns time!Take out what you don’t really need. Don’t be afraid to remove a Design Pattern from your design.If you don’t need it now, don’t do it now.Your Mind on PatternsDon’t forget the power of the shared vocabularyCruisin’ Objectville with the Gang of FourYour journey has just begun...The Patterns ZooAnnihilating evil with Anti-PatternsTools for your Design ToolboxLeaving Objectville...Boy, it’s been great having you in Objectville.
A. Leftover Patterns
BridgeWhy use the Bridge Pattern?BuilderWhy use the Builder Pattern?Chain of ResponsibilityHow to use the Chain of Responsibility PatternFlyweightWhy use the Flyweight Pattern?InterpreterHow to implement an interpreterMediatorMediator in action...MementoThe Memento at workPrototypePrototype to the rescueVisitorThe Visitor drops by
B.
C. Mighty Gumball
Index
About the Authors
Colophon
Copyright

Overview

What’s so special about design patterns?

At any given moment, someone struggles with the same software design problems you have. And, chances are, someone else has already solved your problem. This edition of Head First Design Patterns—now updated for Java 8—shows you the tried-and-true, road-tested patterns used by developers to create functional, elegant, reusable, and flexible software. By the time you finish this book, you’ll be able to take advantage of the best design practices and experiences of those who have fought the beast of software design and triumphed.

What’s so special about this book?

We think your time is too valuable to spend struggling with new concepts. Using the latest research in cognitive science and learning theory to craft a multi-sensory learning experience, Head First Design Patterns uses a visually rich format designed for the way your brain works, not a text-heavy approach that puts you to sleep.

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

Publisher Resources

ISBN: 0596007124Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills