Efnisyfirlit

• Authors of Head First Design Patterns
• Creators of the Head First Series
• Table of Contents (the real thing)
• Intro: How to use this Book
• 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 thinking
• Here’s what WE did:
• Here’s what YOU can do to bend your brain into submission
• Read Me
• We 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 Reviewers
• Tech Reviewers, 2nd Edition
• Acknowledgments
• From the first edition
• Acknowledgments
• From the second edition
• Very Special Thanks
• 1. Welcome to Design Patterns: Intro to Design Patterns
• It started with a simple SimUDuck app
• But now we need the ducks to FLY
• But 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 development
• Zeroing in on the problem…
• Separating what changes from what stays the same
• Designing the Duck Behaviors
• Implementing the Duck Behaviors
• there are no Dumb Questions
• Integrating the Duck Behaviors
• More integration…
• Testing the Duck code
• Setting behavior dynamically
• The Big Picture on encapsulated behaviors
• HAS-A can be better than IS-A
• Speaking of Design Patterns…
• Design Puzzle
• Overheard at the local diner…
• Overheard in the next cubicle…
• The power of a shared pattern vocabulary
• How 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
• 2. Keeping your Objects in the Know: The Observer Pattern
• The Weather Monitoring application overview
• Unpacking the WeatherData class
• Our Goal
• Stretch Goal
• Taking a first, misguided implementation of the Weather Station
• What’s wrong with our implementation anyway?
• Meet the Observer Pattern
• Publishers + Subscribers = Observer Pattern
• A day in the life of the Observer Pattern
• Five-minute drama: a subject for observation
• Two weeks later…
• The Observer Pattern defined
• The Observer Pattern: the Class Diagram
• there are no Dumb Questions
• The Power of Loose Coupling
• Cubicle conversation
• Designing the Weather Station
• Implementing the Weather Station
• Implementing the Subject interface in WeatherData
• Now, let’s build those display elements
• there are no Dumb Questions
• Power up the Weather Station
• Looking for the Observer Pattern in the Wild
• The Swing library
• A little life-changing application
• Coding the life-changing application
• there are no Dumb Questions
• Meanwhile, back at Weather-O-Rama
• For the Subject to send notifications…
• For an Observer to receive notifications…
• Code Magnets
• Test Drive the new code
• Tools for your Design Toolbox
• Design Principle Challenge
• Design Patterns Crossword
• Design Principle Challenge Solution
• Code Magnets Solution
• Design Patterns Crossword Solution
• 3. Decorating Objects: The Decorator Pattern
• Welcome to Starbuzz Coffee
• The Open-Closed Principle
• there are no Dumb Questions
• Meet the Decorator Pattern
• Constructing a drink order with Decorators
• Okay, here’s what we know about Decorators, so far…
• The Decorator Pattern defined
• Decorating our Beverages
• Cubicle Conversation
• New barista training
• Writing the Starbuzz code
• Coding beverages
• Coding condiments
• Serving some coffees
• there are no Dumb Questions
• Real-World Decorators: Java I/O
• Decorating the java.io classes
• Writing your own Java I/O Decorator
• Test out your new Java I/O Decorator
• Tools for your Design Toolbox
• 4. Baking with OO Goodness: The Factory Pattern
• Identifying the aspects that vary
• But the pressure is on to add more pizza types
• Encapsulating object creation
• Building a simple pizza factory
• there are no Dumb Questions
• Reworking the PizzaStore class
• The Simple Factory defined
• Franchising the pizza store
• We’ve seen one approach…
• But you’d like a little more quality control…
• A framework for the pizza store
• Allowing the subclasses to decide
• Let’s make a Pizza Store
• Declaring a factory method
• Let’s see how it works: ordering pizzas with the pizza factory method
• So 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 them
• Now 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 Pattern
• The Creator classes
• The Product classes
• View Creators and Products in Parallel
• Design Puzzle
• Factory Method Pattern defined
• there are no Dumb Questions
• Looking at object dependencies
• The Dependency Inversion Principle
• Applying the Principle
• Inverting your thinking…
• A few guidelines to help you follow the Principle…
• Meanwhile, back at the Pizza Store…
• Ensuring consistency in your ingredients
• Families of ingredients…
• Building the ingredient factories
• Building the New York ingredient factory
• Reworking the pizzas…
• Reworking the pizzas, continued…
• Revisiting our pizza stores
• What 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 factory
• Abstract Factory Pattern defined
• Factory Method and Abstract Factory compared
• Tools for your Design Toolbox
• Design Patterns Crossword
• Design Puzzle Solution
• Design Patterns Crossword Solution
• 5. One-of-a-Kind Objects: The Singleton Pattern
• The Little Singleton
• A small Socratic exercise in the style of The Little Lisper
• Dissecting the classic Singleton Pattern implementation
• The Chocolate Factory
• Singleton Pattern defined
• Hershey, PA, we have a problem…
• BE the JVM
• Dealing with multithreading
• Can 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
• 6. Encapsulating Invocation: The Command Pattern
• Home Automation or Bust, Inc.
• Free hardware! Let’s check out the Remote Control…
• Taking a look at the vendor classes
• Cubicle Conversation
• Meanwhile, back at the Diner…, or, A brief introduction to the Command Pattern
• Let’s study the interaction in a little more detail…
• The Objectville Diner roles and responsibilities
• From the Diner to the Command Pattern
• Our first command object
• Using the command object
• Creating a simple test to use the Remote Control
• The Command Pattern defined
• The Command Pattern defined: the class diagram
• Assigning Commands to slots
• Implementing the Remote Control
• Implementing the Commands
• Putting the Remote Control through its paces
• Now, 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 Undo
• Adding Undo to the Ceiling Fan commands
• Get ready to test the ceiling fan
• Testing the ceiling fan…
• Every remote needs a Party Mode!
• Using a macro command
• there are no Dumb Questions
• More uses of the Command Pattern: queuing requests
• More uses of the Command Pattern: logging requests
• Command Pattern in the Real World
• Tools for your Design Toolbox
• Design Patterns Crossword
• 7. Being Adaptive: The Adapter and Facade Patterns
• Adapters all around us
• Object-oriented adapters
• If 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 adapter
• The Adapter Pattern explained
• Here’s how the Client uses the Adapter
• there are no Dumb Questions
• Adapter Pattern defined
• Object and class adapters
• Duck Magnets
• Duck Magnets Answer
• Real-world adapters
• Enumerators
• Iterators
• Using Enumerators with code that expects Iterators
• Adapting an Enumeration to an Iterator
• Designing the Adapter
• Dealing with the remove() method
• Writing the EnumerationIterator adapter
• And now for something different…
• Home Sweet Home Theater
• Watching a movie (the hard way)
• Lights, Camera, Facade!
• there are no Dumb Questions
• Constructing your home theater facade
• Implementing the simplified interface
• Time to watch a movie (the easy way)
• Facade Pattern defined
• The Principle of Least Knowledge
• How NOT to Win Friends and Influence Objects
• Keeping your method calls in bounds…
• there are no Dumb Questions
• The Facade Pattern and the Principle of Least Knowledge
• Tools for your Design Toolbox
• Design Patterns Crossword
• Design Patterns Crossword Solution
• 8. Encapsulating Algorithms: The Template Method Pattern
• It’s time for some more caffeine
• Whipping up some coffee and tea classes (in Java)
• And now the Tea…
• Let’s abstract that Coffee and Tea
• Taking the design further…
• Abstracting prepareRecipe()
• What have we done?
• Meet the Template Method
• Let’s make some tea…
• What did the Template Method get us?
• Template Method Pattern defined
• Hooked on Template Method…
• Using the hook
• Let’s run the Test Drive
• And let’s give it a run…
• there are no Dumb Questions
• The Hollywood Principle
• The Hollywood Principle and Template Method
• there are no Dumb Questions
• Template Methods in the Wild
• Sorting with Template Method
• We’ve got some ducks to sort…
• What is compareTo()?
• Comparing Ducks and Ducks
• Let’s sort some Ducks
• Let the sorting commence!
• The making of the sorting duck machine
• there are no Dumb Questions
• Swingin’ with Frames
• Custom Lists with AbstractList
• Design Patterns Crossword
• Tools for your Design Toolbox
• Design Patterns Crossword Solution
• 9. Well-Managed Collections: The Iterator and Composite Patterns
• Breaking News: Objectville Diner and Objectville Pancake House Merge
• Check out the Menu Items
• Lou and Mel’s Menu implementations
• What’s the problem with having two different menu representations?
• The Java-Enabled Waitress Specification
• Implementing the spec: our first attempt
• What now?
• Can we encapsulate the iteration?
• Meet the Iterator Pattern
• Adding an Iterator to DinerMenu
• Reworking the DinerMenu with Iterator
• Fixing up the Waitress code
• Testing our code
• Here’s the test run…
• What have we done so far?
• Reviewing our current design…
• Making some improvements…
• there are no Dumb Questions
• Cleaning things up with java.util.Iterator
• We are almost there…
• What does this get us?
• Iterator Pattern defined
• The Iterator Pattern Structure
• The Single Responsibility Principle
• there are no Dumb Questions
• Meet Java’s Iterable interface
• Java’s enhanced for loop
• Not so fast; Arrays are not Iterables
• Taking a look at the Café Menu
• Reworking the Café Menu code
• Adding the Cafe Menu to the Waitress
• Breakfast, lunch, AND dinner
• Here’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 extensible
• But there’s more!
• Iterators and Collections
• Code Magnets
• Is the Waitress ready for prime time?
• Just when we thought it was safe…
• What do we need?
• The Composite Pattern defined
• there are no Dumb Questions
• Designing Menus with Composite
• Implementing MenuComponent
• Implementing the MenuItem
• Implementing the Composite Menu
• Fixing the print() method
• Getting ready for a test drive…
• Now for the test drive…
• Getting ready for a test drive…
• Design Patterns Crossword
• Tools for your Design Toolbox
• Code Magnets Solution
• Design Patterns Crossword Solution
• 10. The State of Things: The State Pattern
• Java Breakers
• Cubicle Conversation
• State machines 101
• Writing the code
• In-house testing
• You knew it was coming…a change request!
• Design Puzzle
• The messy STATE of things…
• The new design
• Defining the State interfaces and classes
• Implementing our State classes
• Reworking the Gumball Machine
• Now, let’s look at the complete GumballMachine class…
• Implementing more states
• Let’s take a look at what we’ve done so far…
• The State Pattern defined
• there are no Dumb Questions
• We still need to finish the Gumball 1 in 10 game
• Finishing the game
• Demo for the CEO of Mighty Gumball, Inc.
• there are no Dumb Questions
• Sanity check…
• We almost forgot!
• Tools for your Design Toolbox
• Design Puzzle Solution
• 11. Controlling Object Access: The Proxy Pattern
• Coding the Monitor
• Testing the Monitor
• The role of the ‘remote proxy’
• Adding a remote proxy to the Gumball Machine monitoring code
• Remote methods 101
• Walking through the design
• How the method call happens
• Java RMI, the Big Picture
• Making the Remote service
• Step one: make a Remote interface
• Step two: make a Remote implementation
• Step four: start the service
• Step four: start the service
• there are no Dumb Questions
• Complete code for the server side
• Complete code for the client side
• Back to our GumballMachine remote proxy
• Getting the GumballMachine ready to be a remote service
• Registering with the RMI registry…
• Now for the GumballMonitor client…
• Writing the Monitor test drive
• Another 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 defined
• Get ready for the Virtual Proxy
• Remote Proxy
• Virtual Proxy
• Displaying Album covers
• Designing the Album Cover Virtual Proxy
• How ImageProxy is going to work:
• Writing the Image Proxy
• Testing the Album Cover Viewer
• Things to try…
• What did we do?
• there are no Dumb Questions
• Using the Java API’s Proxy to create a protection proxy
• Geeky Matchmaking in Objectville
• The Person implementation
• Five-minute drama: protecting subjects
• Big Picture: creating a Dynamic Proxy for the Person
• Step one: creating Invocation Handlers
• Creating Invocation Handlers, continued…
• Step two: creating the Proxy class and instantiating the Proxy object
• Testing the matchmaking service
• Running the code…
• there are no Dumb Questions
• The Proxy Zoo
• Design Patterns Crossword
• Tools for your Design Toolbox
• Design Patterns Crossword Solution
• The code for the Album Cover Viewer
• 12. Patterns of Patterns: Compound Patterns
• Working together
• Duck reunion
• there are no Dumb Questions
• What did we do?
• A duck’s-eye view: the class diagram
• The King of Compound Patterns
• If 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-Controller
• A closer look…
• there are no Dumb Questions
• Understanding MVC as a set of Patterns
• Observer
• Strategy
• Composite
• Using MVC to control the beat…
• Meet the Java DJ View
• The controller is in the middle…
• Let’s not forget about the model underneath it all…
• Putting the pieces together
• Building the pieces
• Let’s check out the BeatModelInterface before looking at the implementation:
• Now let’s have a look at the concrete BeatModel class
• The View
• Implementing the View
• Now for the Controller
• And here’s the implementation of the controller:
• Putting it all together…
• And now for a test run…
• Things to try
• Exploring Strategy
• Adapting the Model
• Now we’re ready for a HeartController
• And that’s it! Now it’s time for some test code…
• And now for a test run…
• Things to try
• there are no Dumb Questions
• Tools for your Design Toolbox
• Exercise Solutions
• The Beat Model
• The View
• The Controller
• The Heart Model
• The Heart Adapter
• The Controller
• 13. Patterns in the Real World: Better Living with Patterns
• Design Pattern defined
• Looking more closely at the Design Pattern definition
• there are no Dumb Questions
• So you wanna be a Design Patterns writer
• Organizing Design Patterns
• Pattern Categories
• Thinking in Patterns
• Keep 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 Patterns
• Don’t forget the power of the shared vocabulary
• Cruisin’ Objectville with the Gang of Four
• Your journey has just begun…
• The definitive Design Patterns text
• The definitive Patterns texts
• Other Design Patterns resources
• The Patterns Zoo
• Annihilating evil with Anti-Patterns
• Tools for your Design Toolbox
• Leaving Objectville…
• Boy, it’s been great having you in Objectville.
• A. Leftover Patterns
• Bridge
• Your dilemma
• Why use the Bridge Pattern?
• Builder
• You need a flexible design
• Why use the Builder Pattern?
• Chain of Responsibility
• A scenario
• Your task
• How to use the Chain of Responsibility Pattern
• Flyweight
• A scenario
• Your big client’s dilemma
• Why use the Flyweight Pattern?
• Interpreter
• A scenario
• Now what?
• How to implement an interpreter
• Mediator
• A scenario
• HouseOfTheFuture’s dilemma
• Mediator in action…
• Memento
• A scenario
• The Memento at work
• Prototype
• A scenario
• Prototype to the rescue
• Visitor
• A scenario
• The Visitor drops by
• Index