Design Patterns in Java: Creational

This course is part of a 3 part series covering design patterns using Java.
Course info
Rating
(502)
Level
Intermediate
Updated
Apr 28, 2015
Duration
1h 54m
Table of contents
Description
Course info
Rating
(502)
Level
Intermediate
Updated
Apr 28, 2015
Duration
1h 54m
Description

This course is part of a 3 part series covering design patterns using Java. This part covers the creational design patterns, Singleton, Builder, Prototype, Factory, and AbstractFactory as defined by the Gang of Four. We look at examples in the Java API and code examples of each pattern.

About the author
About the author

Bryan is a Director at Software Technology Group, a consulting company based out of Salt Lake City, and has authored and taught numerous courses in Java.

More from the author
What’s New in Spring 5
Intermediate
1h 25m
31 Jan 2018
Building Applications Using Spring JDBC
Intermediate
2h 33m
27 Apr 2017
More courses by Bryan Hansen
Section Introduction Transcripts
Section Introduction Transcripts

Introduction & Prerequisites
So you've just been in an interview, and someone asked you to describe a design pattern, or maybe you were just describing a problem to a coworker and they said it sounds like you're reinventing the wheel. They might have even said to you that it sounds like you're describing a factory or a singleton. If this sounds like a situation that you've been in, then this course is for you. Our focus in this course is on presenting the design patterns described in the Gang of Four in an example driven away using Java to do so. Hi. I'm Bryan Hansen, and welcome to Creational Design Patterns using Java.

Singleton Pattern
Hi, this is Bryan Hansen, and in this module we are going to look at the singleton design pattern. The singleton pattern is one of, if not the most, heavily used design patterns because of its simplicity to implement and the type of problem that it solves.

Builder Pattern
Hi. This is Bryan Hansen, and in this module we're going to look at the builder pattern. The builder pattern is a pattern that people often use, but rarely create their own. It is a great pattern for handling the construction of objects that may contain a lot of parameters and we want to make the object immutable once we're done constructing it.

Prototype Pattern
Hi. This is Bryan Hansen, and in this module we are going to look at the prototype design pattern. The prototype pattern is used when the type of object to create is determined by a prototypical instance, which is cloned to produce a new instance. Oftentimes, the prototype pattern is used to get a unique instance of the same object.

Factory Method Pattern
Hi. This is Bryan Hansen, and in this module we are going to look at the factory method design pattern. The factory method pattern is in some ways the opposite of the singleton pattern and probably is the second most used creational design pattern.

AbstractFactory Pattern
Hi. This is Bryan Hansen, and in this module we are going to look at the AbstractFactory design pattern. The AbstractFactory is very similar to the factory method pattern and in fact is typically implemented as a factory of factory patterns.

What Next?
Well thank you for completing this Design Patterns course covering Creational Design Patterns. If you're wondering what to look at next, I might recommend that you keep an eye out for the Design Patterns in Java covering structural design patterns, as well as the course covering behavior of patterns. I'm working on both of those at the time of this being published, and it'll be out shortly. There are also all of my other courses on Pluralsight, Maven Fundamentals, Spring Fundamentals, Spring MVC, Spring MVC 4, Spring JPA Hibernate, and Spring Security just to mention a few. Please explore those other courses if you've enjoyed this, and keep an eye out for those two design patterns courses coming within the next couple of months. Thank you.