Java Design Patterns: Creational

Course details

Design patterns provide a kind of template for writing quality code. Knowing which design pattern to use in which scenario can be challenging, but will make you a better Java programmer. This course takes a deep dive into creational patterns, which can help you create more flexible, reusable objects. Instructor Bethan Palmer covers the five most popular creational patterns—Builder, Singleton, Prototype, Factory Method, and Abstract Factory—as well as concepts such as multithreading, mutability, and hierarchies. She provides example use cases, complete with implementation instructions and tips for avoiding the unique challenges posed by each pattern. By the end of the course, you'll be armed with the knowledge and skills necessary to implement each design pattern in your own Java projects.

Learning objectives
What are creational design patterns?
Avoid complex constructors
Implementing the Builder pattern
Multithreading with the Singleton pattern
Using the Prototype pattern
Implementing a simple Factory Method pattern
Making code more flexible with the Abstract Factory pattern

Concepts

0. Introduction

01 - Improve code with creational design patterns
02 - What you should know

1. Creational Design Patterns

03 - What is a design pattern
04 - Creational design patterns

2. The Builder Pattern

05 - Avoid complex constructors
06 - Implement the Builder pattern
07 - Implement a complete Builder pattern
08 - Complex constructions

3. The Singleton Pattern

09 - When to use the Singleton pattern
10 - Implement the Singleton pattern
11 - Multithreading with the Singleton pattern
12 - Java's Collection class

4. The Prototype Pattern

13 - Understand the Prototype pattern
14 - Implement the Prototype pattern
15 - Dealing with mutability

5. The Factory Method Pattern

16 - Understand the Factory Method pattern
17 - Implement a simple Factory Method pattern
18 - Introduction to hierarchies
19 - The complete Factory Method pattern

6. Abstract Factories

20 - Understand the Abstract Factory pattern
21 - Dealing with extensible factories
22 - Implement the Abstract Factory pattern
23 - Implement extensible factories

Conclusion

24 - Next steps