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

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
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
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
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

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
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
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
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
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
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
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
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
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
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.
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

Content preview from Head First Design Patterns

Chapter 12. Compound Patterns: Patterns of Patterns

Who would have ever guessed that Patterns could work together? You’ve already witnessed the acrimonious Fireside Chats (and you haven’t even seen the Pattern Death Match pages that the editor forced us to remove from the book^[2]), so who would have thought patterns can actually get along well together? Well, believe it or not, some of the most powerful OO designs use several patterns together. Get ready to take your pattern skills to the next level; it’s time for compound patterns.

Working together

One of the best ways to use patterns is to get them out of the house so they can interact with other patterns. The more you use patterns the more you’re going to see them showing up together in your designs. We have a special name for a set of patterns that work together in a design that can be applied over many problems: a compound pattern. That’s right, we are now talking about patterns made of patterns!

You’ll find a lot of compound patterns in use in the real world. Now that you’ve got patterns in your brain, you’ll see that they are really just patterns working together, and that makes them easier to understand.

We’re going to start this chapter by revisiting our friendly ducks in the SimUDuck duck simulator. It’s only fitting that the ...

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.

Start your free trial

Publisher Resources

ISBN: 0596007124Errata Page Supplemental Content

Head First Design Patterns

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

Chapter 12. Compound Patterns: Patterns of Patterns

Working together

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.

You might also like