Praise poured in for this book
Reader Praise
The Head First series has been met with rave reviews.
About the Author
About the creator of the "Head First" series
Translator's Note

Chapter 00 Introduction | How to Read This Book

__ Readers of this book
__Why this book became like this
__ Structure of this book
__How to conquer your brain
__ Note
__ Technical Reviewer
__ Acknowledgements

Chapter 1: Introduction to Design Patterns and Strategic Patterns | Dive into the World of Design Patterns

__ Duck simulation game, SimUduck
__ Differentiating Duck Simulation Games
__ WARNING! SERIOUS PROBLEMS HAPPENED
__ Thinking about inheritance
__ Designing the interface
__ Thinking about how to solve it
__ The immutable truth of software development
__ Clearly identify the problem
__ Separate the parts that change from the parts that don't
__How to design duck behavior
__ How to implement duck behavior
__ Integrating duck behavior
__ Duck Code Test
__ Dynamically specifying actions
__ Examining encapsulated behavior
__ How to merge two classes
__ First Design Pattern: Strategy Pattern
__ Meet the design pattern
__ Patterns and Terminology
__ How to use design patterns
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 2: The Observer Pattern | Communicating with Objects

__ Learn about weather monitoring applications
__ Examining the WeatherData class
__ Implementation Goals
__ Add code for weather station
__ Let's take a look at the additional code with the principle
__ Understanding the Observer Pattern
__ How the Observer Pattern Works
__ Definition of the Observer Pattern
__ Structure of the Observer Pattern
__The power of loose coupling
__ Designing a Weather Station
__Implementing a weather station
Implementing the __ Subject interface
__Implementing display elements
__ Weather Station Test
__ Understanding the Observer Pattern in the Library
__Building life-changing applications
__ Change the code in full
__ Testing the updated weather station code
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 3: Decorator Pattern | Decorating Objects

__ Super-large coffee shop, Starbucks
__ Take a look at OCP
__ Examining the Decorator Pattern
__ Applying the decorator pattern to the ordering system
__Definition of the Decorator Pattern
__ Decorating the Beverage class
__ Practice applying the decorator pattern
__ Creating a coffee ordering system code
__Implementing the drink code
__Implementing the Additive Code
__ Coffee Ordering System Code Test
Example of decorator application: Java I/O
__ java.io classes and the decorator pattern
__ Creating a Java I/O Decorator
__ Testing the newly created Java I/O decorator
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 4: The Factory Pattern | Baking Object-Oriented Bread

__Creating cutting-edge pizza code
__ Add Pizza Code
__ Encapsulating the object creation part
__ Create an object creation factory
__ Modify the client code
__ Definition of 'simple factory'
__ Creating various factories
__ Building a Pizza Shop Framework
__ Find out what subclasses decide
__ Creating a Pizza Style Subclass
__Declaring a factory method
__Ordering a pizza with the pizza factory method
__ Create a Pizza class
__ Cutting-edge pizza code testing
__ A look at the factory method pattern
__ Understanding the Parallel Class Hierarchy
__ Definition of the factory method pattern
__ Examining object dependencies
__ Dependency Inversion Principle
__ Applying the dependency inversion principle
__ Reverse your thinking
__How to follow the dependency inversion principle
__ Learn about the types of raw materials
__ Group by raw material group
__ Creating a raw materials factory
__ Creating a New York Raw Materials Factory
__ Change the Pizza class
__Use the right material factory
__ Looking back at what's changed
__Order another pizza with a new code
__ Definition of the Abstract Factory Pattern
__ Factory Method Pattern and Abstract Factory Pattern
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 5: The Singleton Pattern | Creating a Unique, Special Object

__ Get to know Little Singleton
__ How to implement the classic singleton pattern
__ Examining the Chocolate Boiler Code
__ Definition of the Singleton Pattern
__Hershey! There's a problem with the chocolate boiler.
__ Examining multithreading issues
__Troubleshooting multithreading issues
__ Solving multithreading problems more efficiently
__Choosing the right way to solve the problem
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 6: Command Patterns | Encapsulating Calls

__ Universal IoT remote control
__ Explore the Partner Class
__ Introducing the Command Pattern
__ A closer look at the food ordering process
__ Roles of the characters in Object Village Restaurant
__ Object Village Restaurant and Command Pattern
__ Creating the first command object
__ Using command objects
__ Definition of the command pattern
__ Examining the Command Pattern Class Diagram
Assigning commands to __ slots
__ Create a remote control code
__ Creating a command class
__ Remote Control Test
__ Creating API Documentation
__ Add a cancel function
__ Test the cancel task function
__ How to use state when implementing a cancel operation function
__ Add a cancel function to the fan command
__ Create a fan test code
__ Fan Code Test
__ Processing multiple actions at once
Using the __ macro command
__Using the command pattern
__ Using the command pattern more
__ Practical Application! Command Patterns
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 7: Adapter and Facade Patterns | Adapting

__ Take a look at the adapter
__ Understanding Object-Oriented Adapters
__ Learn how to use the adapter
__ Duck Adapter Test
__ Understanding the Adapter Pattern
__ Definition of the adapter pattern
__ Object Adapter and Class Adapter
__Practical Application! Adapter Pattern
__ Adapting Enumeration to Iterator
__ Preview of the facade pattern
__ Building a Home Theater
__ Watching movies in a complicated way
__ Learn how Facade works
__ Creating a Home Theater Facade
__ Creating a simplified interface
__ Watch movies the easy way
__ Definition of the Facade Pattern
__ Principle of Least Knowledge
__ Influence other objects without making friends
__ Calling methods only on close friends
__ Facade Pattern and Least Knowledge Principle
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 8: Template Method Pattern | Encapsulating Algorithms

__ Making coffee and tea
__ Creating Coffee and Tea classes
__ Abstracting the Coffee and Tea classes
__ A Look Inside the Abstraction Method
Abstracting the __ prepareRecipe( ) method
__ Revisiting the process of making coffee and tea
__ Learn about the template method pattern
__ Learn about the benefits of the template method pattern
__ Definition of the template method pattern
__ Understanding hooks in template methods
Using __ hooks
__ Hook code test
__Hollywood Principle
__Hollywood Principles and Template Method Pattern
__ Understanding the Template Method Pattern in Java API
__ How to sort with template methods
__ Sort the ducks
__Comparing the size of ducks
__ Duck sort code test
__ Outputting graphics using template methods
__ Create your own list with AbstractList
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 9: Iterator and Composite Patterns | Managing Collections Well

Breaking News! Object Village Restaurant and Pancake House Merger
__ Browse menu items
__ Comparing the menu implementations of Ru and Mel
Implementing the __ Qualification Requirements: First Attempt
__ Encapsulating repetition
__ Understanding the iterator pattern
__ Adding an iterator to the Object Village restaurant menu
__ Using iterators in the Object Village restaurant menu
__ Applying an iterator to employee code
__ Employee Code Test
__ Understanding the characteristics of the iterator pattern
__ Revisiting the Integrated Restaurant Code
__ Improving the interface
__ Applying java.util.Iterator
__ Check out the changed integrated restaurant code
__ Definition of the iterator pattern
__ Understanding the structure of the iterator pattern
__ Single Role Principle
__ Understanding the Iterable interface
__ Learn about the improved for loop
__ Precautions when using the enhanced for loop
__ Check out the Object Village Cafe menu
__ Fixing the Object Village Cafe menu code
__ Adding a cafe menu to employee code
__ Integrated restaurant code testing with added cafe menu
__Iterators and Collections
__Improving Employee Code
__ Preparing for refactoring
__ Definition of the Composite Pattern
__Designing menus with the composite pattern
__Implementing the menu component
Implementing the __ menu item
__ Implementing the menu
__ Applying composites to employee code
__ Menu Code Test
__ Menu code test results
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 10: State Patterns | Changing Object States

__ State-of-the-art lottery machine
__ Learn the basics of state machines
__ Creating a Gacha Machine Code
__ Test the lottery machine code
__Notice! Request for modification of the lottery machine code
__ View Requests
__Conceive a new design
__ Defining the State interface and class
__ Implementing the State class
__ Modify the lottery machine code
__ Take a look at the full code for the gacha machine
__Implementing another state class
__ Revisiting the structure of the gacha machine
Definition of the __ state pattern
__ Add bonus kernel winning feature
__ Try the demo version
__ Check normality
__ Try adding a refill function
__ Tools that should be in your design toolbox
__ Practice Problem Answers

Chapter 11: Proxy Pattern | Controlling Object Access

__ Creating monitoring code
__ Monitoring function test
__ The role of remote proxy
__ Adding a remote proxy to your monitoring code
__ Basics of Remote Methods
__ Understanding the method call process
__ Overview of Java RMI
__ Creating a remote service
Step 1: Creating a Remote Interface
Step 2: Create a service implementation class
Step 3: Run rmiregistry
Step 4: Running the Remote Service
__ Examine the code required for the server
__ Examining the client code
__ Considering a remote proxy for the gacha machine
__ Converting the GumballMachine class into a remote service
__ Registering the RMI Registry
__ Fixing the GumballMonitor client code
__ Testing new monitoring features
__ Create a demo version
__ Try the demo version
__ Definition of the proxy pattern
__Comparing remote proxies and virtual proxies
__ Create an album cover viewer
__ Designing a Virtual Proxy for Album Covers
__ Creating ImageProxy code
__ Album Cover Viewer Test
__ Create a protective proxy
__ Object Village Dating Service
__ Create Person interface code
__ Creating a dynamic proxy for the Person interface
__ Step 1: Creating an InvocationHandler
Step 2: Create dynamic proxy generation code
__ Dating Service Code Test
__ Dating Service Code Test Results
__ Real Life! Exploring the Proxy Zoo
__ Tools that should be in your design toolbox
__ Practice Problem Answers
__ Prepared Code: Album Cover Viewer Code

Chapter 12 Composite Patterns | Creating Patterns by Combining Patterns

__ Mixing patterns
__ Applying various patterns to the duck simulation game
__ Looking back at what's changed
__ Examining the Duck Simulation Game Class Diagram
__ Meet the King of Composite Patterns
__ Understanding Model-View-Controller
__Learn more about Model-View-Controller
__ Learn about the patterns used in Model-View-Controller
__ Building a BPM Control Tool with Model-View-Controller
__ Model, View, and Controller Combined View
__ Creating models, views, and controllers
__ Create a model
__ Learn more about the view
__ Create a view
__ Create a controller
__ Take a look at the controller code
__Merge model, view, and controller code
__Learn more about the strategy pattern in MVC
__ Adapting the heart rate monitor model
__ Building a Heart Rate Monitor Controller
__ Heart Rate Monitor Code Test
__ Tools that should be in your design toolbox
__ Practice Problem Answers
__ Prepared Code: BPM Control Tool Code

Chapter 13: Practical Design Patterns | Living Happily with Patterns

__ Definition of design patterns
__ A closer look at the definition of design patterns
__ Discovering new design patterns
__ Classifying design patterns
__ Learn about design pattern categories
Thinking in __ patterns
__ Attitude towards patterns
__Recalling the power of technical terms
__ A trip to Object Village with the Four
__ Go find the pattern
__ Real-World! Exploring the Pattern Zoo
__ Destroying evil anti-patterns
__ Tools that should be in your design toolbox
__ Leaving Object Village
__ Practice Problem Answers

Chapter 14: Other Patterns | Quickly Learn Various Patterns

__ Bridge Pattern
__ Builder Pattern
__Chain of Responsibility Pattern
__ Flyweight Pattern
__ Interpreter Pattern
__ Mediator Pattern
__ Memento Pattern
__ Prototype Pattern
__ Visitor Pattern

Search

You must read this book!

· Software launches are perfection itself! "Huh? I went back to fix the code and it was a mess..."
→ Junior (Java) developer who just thinks about maintenance and tears

· Coding skills are a major asset! "Huh? So this is how you apply the factory method pattern?"
→ Senior (Java) developers who want to review design patterns again

· Programming language skills honed through self-study! "Huh? But what's a pattern?"
→ Aspiring developers who are curious about software design methods in the development field.

For a long time, across careers and generations
Helping object-oriented developers grow
The glorious return of the design pattern textbook!

* Undisputed No. 1 in design pattern books since 2005
* The classic and bible of design patterns

· Design patterns are problem-solving methods based on the experiences of seniors.

Since ancient times, preliminary design has been important when constructing a building.
When any problem or modification occurs, it is time-consuming and expensive to rebuild through trial and error.
People have discovered patterns in problems that arise in specific situations based on their own trial and error and recorded solutions to avoid repeating the same mistakes.
This is called a 'design pattern'.
Design patterns, which originated in architecture, can be equally applied to software design in that we build software with code.
Since a problem experienced by someone is not a problem experienced only by someone else, we can pursue efficiency in software design by utilizing the knowledge of seniors who have experienced the same problem before.

· Design patterns save time and effort

There is no perfect software in the world.
Because technology and user needs change with the times.
When programming, you should always think, 'I will have to fix this software someday.'
If you design your software so that fixes beforehand have minimal impact on your code, you can spend more time building better software and less time coding.
The usefulness of design patterns doesn't stop at simply 'reusing' the code of our predecessors.
It can also be applied to leading teams, executing projects, and solving problems that may arise in various forms.
If you have a deep understanding of 'design patterns', you can efficiently suggest the right solution for the right place, and you can communicate efficiently with one sentence, "Let's use the Observer pattern!" instead of having to explain at length, "Let's solve this problem by creating a broadcast class that can keep track of all objects listening to it, send a message to each listener whenever new data comes in, and listeners can join or leave the listener list at any time!"


· Design patterns are tools that should be used appropriately for their intended purpose.

But design patterns are not a panacea.
Just as you wouldn't burn down a house to catch a flea, you shouldn't apply a pattern to any code.
Applying patterns to programs like "Hello, World!" will only make the code more complex, harder for others to understand, and harder to maintain, ultimately leading to disaster.
Design patterns are simply tools for creating good software.
Every tool is powerful when used appropriately for its intended purpose.
In fact, it takes a lot of time and effort to learn which code to use design patterns for.
Because you need to fully understand design patterns to know which code is spaghetti code.
But what if there was a book that distilled the core elements of design patterns into a fun and engaging explanation? Wouldn't you be happy to learn design patterns with minimal time and effort? You don't have to look far for such a book.
Because 『Head First Design Patterns (Revised Edition)』 is right here.


What's Covered in Head First Design Patterns (Revised Edition)

Since its publication in 2005, "Head First Design Patterns" has maintained its position as the undisputed number one bestseller in the design pattern field for 17 years.
The reason it is loved by many developers across careers and generations is because it covers only the 'core of GoF design patterns'.


* When and why to use the 14 GoF core patterns!
* How to apply it to your designs immediately!
* Situations where you should not use it!
* Object-oriented design principles that form the basis of patterns!
* Definitions and usage of 9 other patterns that are good to know!

What's New in Head First Design Patterns (Revised Edition)

* Modified example code to run smoothly on Java 8, which is commonly used, and the latest version, Java 16 or higher.
*Added additional explanations and Q&A questions
* New illustrations and Korean-friendly layout exclusively for Korean readers

* To commemorate the first revision in 16 years, we have created a new Korean edition to make learning design patterns more comfortable than the first edition.

Features of the Head First series

And it's really important to learn design patterns in a way that's not boring.
If you've read even one book in the Head First series, you'll probably have an idea of ​​what this book is about.
It is structured in a way that 'there is a lot to see and it gets right into your head', so your head reacts first.


* Comfortable conversational style, like talking to a friend!
* A witty composition that is hard to predict!
* Over 90 challenging practice problems!
* An interesting story that can be thought of from many perspectives!
* Simple example code that you can follow quickly!

It also covers how to avoid pattern addiction and how to discover design patterns, which will be helpful for future pattern designers.

Download example files

→ https://www.hanbit.co.kr/src/10526
→ https://wickedlysmart.com/head-first-design-patterns

Related books

This is Java (Hanbit Media, 2015)
Study Java on Your Own (Hanbit Media, 2019)
This is C# (Hanbit Media, 2021)
Design Patterns: Easy to Learn and Use Right Away (Hanbit Media, 2020)
Machine Learning Design Patterns (Hanbit Media, 2021)