book

Head First Design Patterns, 2nd Edition

by Eric Freeman, Elisabeth Robson

December 2020

Beginner

672 pages

15h 24m

English

O'Reilly Media, Inc.

Read now

Unlock full access

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 did:Here’s what YOU can do to bend your brain into submissionRead MeWe use simple UML-like diagrams.We don’t cover every single Design Pattern ever created.The activities are NOT optional.We use the word “composition” in the general OO sense, which is more flexible than the strict UML use of “composition.”The redundancy is intentional and important.The code examples are as lean as possible.The Brain Power exercises don’t have answers.Tech ReviewersTech Reviewers, 2nd EditionAcknowledgmentsFrom the first editionAcknowledgmentsFrom the second editionVery Special Thanks
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 Behaviorsthere are no Dumb QuestionsIntegrating the Duck BehaviorsMore integration...Testing the Duck codeSetting behavior dynamicallyThe Big Picture on encapsulated behaviorsHAS-A can be better than IS-ASpeaking of Design Patterns... Design PuzzleOverheard at the local diner...Overheard in the next cubicle...The power of a shared pattern vocabularyHow do I use Design Patterns?there are no Dumb Questions Tools for your Design Toolbox Design Patterns Crossword Design Puzzle Solution Design Patterns Crossword Solution
The Weather Monitoring application overviewUnpacking the WeatherData classOur GoalStretch GoalTaking a first, misguided implementation of the Weather StationWhat’s wrong with our implementation anyway?Meet the Observer PatternPublishers + Subscribers = Observer PatternA day in the life of the Observer Pattern Five-minute drama: a subject for observationTwo weeks later...The Observer Pattern definedThe Observer Pattern: the Class Diagramthere are no Dumb QuestionsThe Power of Loose CouplingCubicle conversationDesigning the Weather StationImplementing the Weather StationImplementing the Subject interface in WeatherDataNow, let’s build those display elementsthere are no Dumb QuestionsPower up the Weather StationLooking for the Observer Pattern in the WildThe Swing libraryA little life-changing applicationCoding the life-changing applicationthere are no Dumb QuestionsMeanwhile, back at Weather-O-RamaFor the Subject to send notifications...For an Observer to receive notifications...Code MagnetsTest Drive the new code Tools for your Design Toolbox Design Principle Challenge Design Patterns Crossword Design Principle Challenge SolutionCode Magnets Solution Design Patterns Crossword Solution
Welcome to Starbuzz CoffeeThe Open-Closed Principlethere are no Dumb QuestionsMeet the Decorator PatternConstructing a drink order with DecoratorsOkay, here’s what we know about Decorators, so far...The Decorator Pattern definedDecorating our BeveragesCubicle ConversationNew barista trainingWriting the Starbuzz codeCoding beveragesCoding condimentsServing some coffeesthere are no Dumb QuestionsReal-World Decorators: Java I/ODecorating the java.io classesWriting your own Java I/O DecoratorTest out your new Java I/O Decorator Tools for your Design Toolbox
Identifying the aspects that varyBut the pressure is on to add more pizza typesEncapsulating object creationBuilding a simple pizza factorythere are no Dumb QuestionsReworking 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 Pizza StoreDeclaring 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: Pizzas!Our Pizza Store 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 classesView Creators and Products in Parallel Design PuzzleFactory Method Pattern definedthere are no Dumb QuestionsLooking at object dependenciesThe Dependency Inversion PrincipleApplying the PrincipleInverting your thinking...A few guidelines to help you follow the Principle...Meanwhile, back at the Pizza Store...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...Ethan and Joel can’t get enough Objectville Pizza! What they don’t know is that now their orders are making use of the new ingredient factories. So now when they order...From here things change, because we are using an ingredient factoryAbstract Factory Pattern definedFactory Method and Abstract Factory compared Tools for your Design Toolbox Design Patterns Crossword Design Puzzle Solution Design Patterns Crossword Solution
The Little SingletonA small Socratic exercise in the style of The Little LisperDissecting the classic Singleton Pattern implementationThe Chocolate FactorySingleton Pattern definedHershey, PA, we have a problem...BE the JVMDealing 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!there are no Dumb Questions Tools for your Design Toolbox Design Patterns Crossword Design Patterns Crossword Solution
Home Automation or Bust, Inc.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 Ceiling Fan commandsGet ready to test the ceiling fanTesting the ceiling fan...Every remote needs a Party Mode!Using a macro commandthere are no Dumb QuestionsMore uses of the Command Pattern: queuing requestsMore uses of the Command Pattern: logging requestsCommand Pattern in the Real World Tools for your Design Toolbox Design Patterns Crossword

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 Adapterthere are no Dumb QuestionsAdapter Pattern definedObject and class adaptersDuck MagnetsDuck Magnets AnswerReal-world adaptersEnumeratorsIteratorsUsing Enumerators with code that expects IteratorsAdapting 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!there are no Dumb QuestionsConstructing 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...there are no Dumb QuestionsThe Facade Pattern and the Principle of Least Knowledge Tools for your Design Toolbox Design Patterns Crossword Design Patterns Crossword Solution
It’s time for some more caffeineWhipping up some coffee and tea classes (in Java)And now the Tea...Let’s abstract that Coffee and TeaTaking 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 DriveAnd let’s give it a run...there are no Dumb QuestionsThe Hollywood PrincipleThe Hollywood Principle and Template Methodthere are no Dumb QuestionsTemplate Methods in the WildSorting with Template MethodWe’ve got some ducks to sort...What is compareTo()?Comparing Ducks and DucksLet’s sort some DucksLet the sorting commence!The making of the sorting duck machinethere are no Dumb QuestionsSwingin’ with FramesCustom Lists with AbstractList Design Patterns Crossword Tools for your Design Toolbox Design Patterns Crossword Solution
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 SpecificationImplementing the spec: our first attemptWhat now?Can we encapsulate the iteration?Meet the Iterator PatternAdding an Iterator to DinerMenuReworking the DinerMenu with IteratorFixing up the Waitress codeTesting our codeHere’s the test run...What have we done so far?Reviewing our current design...Making some improvements...there are no Dumb QuestionsCleaning things up with java.util.IteratorWe are almost there...What does this get us?Iterator Pattern definedThe Iterator Pattern StructureThe Single Responsibility Principlethere are no Dumb QuestionsMeet Java’s Iterable interfaceJava’s enhanced for loopNot so fast; Arrays are not IterablesTaking a look at the Café MenuReworking the Café Menu codeAdding the Cafe 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 CollectionsCode MagnetsIs the Waitress ready for prime time?Just when we thought it was safe...What do we need?The Composite Pattern definedthere are no Dumb QuestionsDesigning Menus with CompositeImplementing MenuComponentImplementing the MenuItemImplementing the Composite MenuFixing the print() methodGetting ready for a test drive...Now for the test drive...Getting ready for a test drive... Design Patterns Crossword Tools for your Design ToolboxCode Magnets Solution Design Patterns Crossword Solution
Java BreakersCubicle ConversationState machines 101Writing the codeIn-house testingYou knew it was coming...a change request! Design PuzzleThe 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 definedthere are no Dumb QuestionsWe still need to finish the Gumball 1 in 10 gameFinishing the gameDemo for the CEO of Mighty Gumball, Inc.there are no Dumb QuestionsSanity check...We almost forgot! Tools for your Design Toolbox Design Puzzle Solution
Coding the MonitorTesting the MonitorThe role of the ‘remote proxy’Adding a remote proxy to the Gumball Machine monitoring codeRemote methods 101Walking through the designHow the method call happensJava RMI, the Big PictureMaking the Remote serviceStep one: make a Remote interfaceStep two: make a Remote implementationStep four: start the serviceStep four: start the servicethere are no Dumb QuestionsComplete code for the server sideComplete code for the client sideBack 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 it:The Proxy Pattern definedGet ready for the Virtual ProxyRemote ProxyVirtual ProxyDisplaying Album coversDesigning the Album Cover Virtual ProxyHow ImageProxy is going to work:Writing the Image ProxyTesting the Album Cover ViewerThings to try...What did we do?there are no Dumb QuestionsUsing the Java API’s Proxy to create a protection proxyGeeky Matchmaking in ObjectvilleThe Person implementation Five-minute drama: protecting subjectsBig Picture: creating a Dynamic Proxy for the PersonStep one: creating Invocation HandlersCreating Invocation Handlers, continued...Step two: creating the Proxy class and instantiating the Proxy objectTesting the matchmaking serviceRunning the code...there are no Dumb QuestionsThe Proxy Zoo Design Patterns Crossword Tools for your Design Toolbox Design Patterns Crossword SolutionThe code for the Album Cover Viewer
Working togetherDuck reunionthere are no Dumb QuestionsWhat 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 Model-View-ControllerA closer look...there are no Dumb QuestionsUnderstanding MVC as a set of PatternsObserverStrategyCompositeUsing 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 implementation:Now let’s have a look at the concrete BeatModel classThe ViewImplementing the ViewNow for the ControllerAnd here’s the implementation of the controller:Putting it all together...And now for a test run...Things to tryExploring 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 trythere are no Dumb Questions Tools for your Design Toolbox Exercise SolutionsThe Beat ModelThe ViewThe ControllerThe Heart ModelThe Heart AdapterThe Controller
Design Pattern definedLooking more closely at the Design Pattern definitionthere are no Dumb QuestionsSo 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 definitive Design Patterns textThe definitive Patterns textsOther Design Patterns resourcesThe Patterns ZooAnnihilating evil with Anti-Patterns Tools for your Design ToolboxLeaving Objectville...Boy, it’s been great having you in Objectville.
BridgeYour dilemmaWhy use the Bridge Pattern?BuilderYou need a flexible designWhy use the Builder Pattern?Chain of ResponsibilityA scenarioYour taskHow to use the Chain of Responsibility PatternFlyweightA scenarioYour big client’s dilemmaWhy use the Flyweight Pattern?InterpreterA scenarioNow what?How to implement an interpreterMediatorA scenarioHouseOfTheFuture’s dilemmaMediator in action...MementoA scenarioThe Memento at workPrototypeA scenarioPrototype to the rescueVisitorA scenarioThe Visitor drops by

Content preview from Head First Design Patterns, 2nd Edition

Intro: How to use this Book

Note

In this section, we answer the burning question: “So, why DID they put that in a design patterns book?”

Who is this book for?

If you can answer “yes” to all of these:

Do you know Java (you don’t need to be a guru) or another object-oriented language?

Note

All our examples are in Java, but you should be able to understand the main concepts of the book if you know another object-oriented language.
Do you want to learn, understand, remember, and apply design patterns, including the OO design principles upon which design patterns are based?
Do you prefer stimulating dinner party conversation to dry, dull, academic lectures?

this book is for you.

Who should probably back away from this book?

If you can answer “yes” to any one of these:

Are you completely new to object-oriented programming?
Are you a kick-butt object-oriented designer/developer looking for a reference book?
Are you an architect looking for enterprise design patterns?
Are you afraid to try something different? Would you rather have a root canal than mix stripes with plaid? Do you believe that a technical book can’t be serious if object-oriented concepts are anthropomorphized?

this book is not for you.