Development
Web Development
Design Pattern
Java Design Patterns & SOLID Design Principles
4.5 (1,111 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
8,988 students enrolled

Java Design Patterns & SOLID Design Principles

A master guide to gang of four design patterns & SOLID design principles using Java
4.5 (1,111 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
8,988 students enrolled
Created by Coffee Powered Crew
Last updated 5/2020
English
English [Auto], Indonesian [Auto], 3 more
  • Polish [Auto]
  • Romanian [Auto]
  • Thai [Auto]
Preview this course
Java Design Patterns & SOLID Design Principles
Current price: $57.99 Original price: $89.99 Discount: 36% off
14 hours left at this price!
Buy now
30-Day Money-Back Guarantee
This course includes
  • 17 hours on-demand video
  • 1 article
  • 98 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Master 26 design patterns including 23 design patterns of gang of four & other new modern design patterns
  • Master the SOLID design principles using Java with hands on examples along with design patterns
  • Get a complete understanding of Java design patterns & understand where to use them in Java code
  • Learn the differences between competing design patterns to choose correct solution to your problem
  • Get real world examples of design patterns usage with hands on projects for every design pattern
  • Become senior Java developer by learning about design patterns and SOLID design principles
  • Understand & implement all creational, structural & behavioral gang of four design patterns using Java
  • Understand & implement Null Object, Object Pool design patterns using Java
  • Comprehensive knowledge about limitations, comparisons, real world usage & hand on examples of design patterns using Java
Course content
Expand all 253 lectures 17:00:55
+ – SOLID Design Principles
11 lectures 01:10:13
Section Introduction
Preview 01:06

Learn about the Single Responsibility Principle here. This is the first one from SOLID design principles.

Single Responsibility Principle
03:42

Let's try out the Single Responsibility principle with some java code.

Single Responsibility Principle - Hands on
12:28

The second principle from SOLID design principles.

Open-Closed Principle
02:28

Try out the open-closed principle in a Java hands on example.

Open-Closed Principle - Hands On
10:39

Let's learn about Liskov substitution in this lecture.

Liskov Substitution Principle
01:35

We'll see the famous example of Liskov Substitution principle.

Liskov Substitution Principle - Hands On
10:54

This easy to follow but important principle is explained in this lecture.

Interface Segregation Principle
02:20

See how interface segregation can be applied in Java code.

Interface Segregation Principle - Hands On
07:52

The famous DI principle.

Dependency Inversion Principle
07:43

Let's try out the dependency inversion ourselves in this Java hands on example.

Dependency Inversion Principle - Hands On
09:26

Let's test your knowledge about SOLID principles in this quiz.

SOLID Principles Quiz
6 questions
+ – Introduction
1 lecture 01:59
Design Patterns - Introduction
Preview 01:59

Let's test your knowledge of categories of design patterns. In case you get any of these wrong, don't worry! You can always go back and watch the lecture again to revise.

Quiz - Design Pattern Introduction
2 questions
+ – Builder
10 lectures 45:15

In this video we'll introduce the builder design pattern. Builder is one of the most easy & useful creational design patterns. It can be used with legacy code as well as new code. 

Builder - Introduction
Preview 06:49

Let's talk about the typical steps you'd follow when implementing builder design pattern.

Builder Implementation Steps
Preview 01:57

In this video we'll go over the UML diagram of the example which we're going to implement in next video. This video will clarify role of each class we'll be either using or implementing ourselves.

Builder - Example UML
Preview 01:46

Let' s implement builder design pattern now in Java. In this video we are going to try out one way to implement this pattern. 

Builder - Implementation Part 1
Preview 14:13

In this video we're going to implement builder in another fashion. n fact this is the way you'll often see builder used in real life projects.

Builder - Implementation Part 2
Preview 03:45

In this video we're going to look at some points you should consider while designing & implementing this design pattern.

Builder - Implementation & Design Considerations
Preview 03:06
Builder - Examples
Preview 03:40

Now let's compare builder pattern with Prototype design pattern.

Builder - Comparison with Prototype
Preview 02:59

This video discusses short comings of builder design pattern.

Builder - Pitfalls
Preview 02:06

In this video we will discuss summary of builder design pattern

Builder - Summary
Preview 04:54

Let's test your knowledge of the builder design pattern. In case you get some of these wrong, don't worry! You can go back and watch any lectures on builder pattern again and then try again.


Quiz - Builder Design Pattern
4 questions
+ – Simple Factory
8 lectures 13:34

In this video we'll introduce Simple factory.

Simple Factory - Introduction
02:35

Let's talk about the typical steps you'd follow when implementing a simple factory.

Simple Factory - Implementation Steps
00:49

Let' s implement a simple factory now in Java.

Simple Factory - Implementation
04:22

In this video we're going to look at some points you should consider while designing & implementing simple factory

Simple Factory - Implementation & Design Considerations
01:12
Simple Factory - Example
01:24

Now let's compare simple factory with factory method design pattern

Simple Factory - Comparison with Factory Method
00:53

This video discusses short comings of simple factory.

Simple Factory - Pitfalls
00:42

In this video we will discuss summary of simple factory

Simple Factory - Summary
01:37

Let's test your knowledge on Simple Factory. In case you get any of these wrong, don't worry! You can always go back and watch the lectures again to revise.

Quiz - Simple Factory
2 questions
+ – Factory Method
8 lectures 21:06

In this video we'll introduce the builder design pattern.

Factory Method - Introduction
02:26

Let's talk about the typical steps you'd follow when implementing factory method design pattern.

Factory Method - Implementation Steps
01:00
In this video we'll go over the UML diagram of the example which we're going to implement in next video. This video will clarify role of each class we'll be either using or implementing ourselves.
Factory Method - Example UML
01:35

Let' s implement factory method design pattern now in Java. In this video we are going to try out one way to implement this pattern.

Factory Method - Implementation
06:02
In this video we're going to look at some points you should consider while designing & implementing this design pattern.
Factory Method - Implementation & Design Considerations
02:12
Factory Method - Example
02:01

This video discusses short comings of factory method 

design pattern.
Factory Method - Pitfalls
00:54

In this video we will discuss summary of factory method design pattern

Factory Method - Summary
04:56

Let's test your knowledge on Factory Method. In case you get any of these wrong, don't worry! You can always go back and watch the lectures again to revise.

Quiz - Factory Method
3 questions
+ – Prototype
9 lectures 26:12

In this video we'll introduce the prototype design pattern. Prototype allows us to use existing objects to create more of them!

Prototype - Introduction
02:12

Let's talk about the typical steps you'd follow when implementing prototype design pattern.

Prototype - Implementation Steps
02:03

In this video we'll go over the UML diagram of the example which we're going to implement in next video. This video will clarify role of each class we'll be either using or implementing ourselves.

Prototype - Example UML
00:58

Let's implement prototype design pattern now in Java.

Prototype - Implementation
11:34

In this video we're going to look at some points you should consider while designing & implementing this design pattern.

Prototype - Implementation & Design Considerations
02:50
Prototype - Example
01:09

Now let's compare prototype pattern with singleton design pattern.

Prototype - Comparison with Singleton
01:19

This video discusses short comings of prototype design pattern.

Prototype - Pitfalls
01:17

In this video we will discuss summary of prototype design pattern

Prototype - Summary
02:50

Let's test your knowledge on Prototype design pattern. In case you get any of these wrong, don't worry! You can always go back and watch the lectures again to revise.

Quiz - Prototype Design Pattern
3 questions
+ – Abstract Factory
9 lectures 39:15

In this video we'll introduce the abstract factory design pattern.

Abstract Factory - Introduction
09:16

Let's talk about the typical steps you'd follow when implementing abstract factory design pattern.

Abstract Factory - Implementation Steps
01:33

In this video we'll go over the UML diagram of the example which we're going to implement in next video. This video will clarify role of each class we'll be either using or implementing ourselves.

Abstract Factory - Example UML
02:55

Let's implement abstract factory design pattern now in Java.

Abstract Factory - Implementation
09:15

In this video we're going to look at some points you should consider while designing & implementing this design pattern.

Abstract Factory - Implementation & Design Considerations
02:09
Abstract Factory - Example
06:05

Now let's compare builder pattern with abstract factory design pattern

Abstract Factory - Comparison with Factory Method
01:15

This video discusses short comings of abstract factory design pattern.

Abstract Factory - Pitfalls
01:25

In this video we will discuss summary of abstract factory design pattern

Abstract Factory - Summary
05:22

Now, let's test your knowledge on Abstract Factory design pattern. In case you get any of these wrong, don't worry! You can always go back and watch the lectures again to revise.

Quiz - Abstract Factory
3 questions
+ – Singleton
11 lectures 41:03
Singleton - Introduction
01:58
Singleton - Implementation Steps
01:53
Singleton - Implementation - Eager Singleton
03:39
Singleton - Implementation - Lazy Singleton
06:17
Singleton - Implementation - Initialization Holder
07:20
Singleton - Implementation - Enum
02:59
Singleton - Implementation & Design Considerations
03:29
Singleton - Example
01:04
Singleton - Comparison with Factory Method
01:07
Singleton - Pitfalls
02:04
Singleton - Summary
09:13

Let's test your knowledge on Singleton design pattern. In case you get any of these wrong, don't worry! You can always go back and watch the lectures again to revise.

Quiz - Singleton
4 questions
+ – Object Pool
9 lectures 42:10
Object Pool - Introduction
03:14
Object Pool - Implementation Steps
01:33
Object Pool - Example UML
02:04
Object Pool - Implementation
15:51
Object Pool - Implementation & Design Considerations
04:52
Object Pool - Example
03:58
Object Pool - Comparison with Prototype
01:17
Object Pool - Pitfalls
02:06
Object Pool - Summary
07:15

Let's test your knowledge on Object Pool design pattern. In case you get any of these wrong, don't worry! You can always go back and watch the lectures again to revise.

Quiz - Object Pool
3 questions
Requirements
  • You should have a basic knowledge of Java & basic programming concepts
  • If you want to follow along, you need any Java code editor & a computer to run it
Description

Course Overview

    This course starts with SOLID Design Principles in Java. It will then provide a comprehensive introduction to Java Design patterns with practical, hands on exercises.


What are SOLID Design Principles?

SOLID design principles are almost a mandatory skill for every Java developer. These principles enable you to write most reusable & clean Java code in your projects.

You'll learn SOLID Principles which are:

Single Responsibility Principle

Open-Closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle


All these principles are explained in detail and you'll refactor existing Java code and apply these principles in hands on exercise along with me.

Then we move on to Java Design Patterns.

To learn about the design patterns using Java programming language we'll discuss:   

  •     Learn what kind of problems are solved by each design pattern.

  •     Discuss various roles in the design pattern using UML diagrams.

  •     We'll use UML of example that we are going to solve as well as UMLs from gang of four book

  •     Discuss how the design  pattern is applied in the example & how various parts fit together.

  •     Hands on example using Java in Eclipse IDE that uses the design pattern.

  •     Various design & implementation considerations for every design pattern.

  •     Discuss how the design pattern varies from another similar pattern.

  •     See where a design pattern is used in real life.

This course covers all the classic design patterns from the Gang of Four (GoF) book. In addition we'll discuss few newer design patterns that are used in modern software development. We'll discuss how a pattern can be implemented in various ways & how we can tailor them to be used with Java language.

This course is the Most Comprehensive course on Java Design Patterns that you can find.


So, what are Design Patterns & why should you care?

    Design patterns represent solutions to common problems, which you face while doing programming. These solutions are reusable and can solve a wide variety of problems. These became popular with the release of classic book on the subject "Elements of Reusable Object-Oriented Software" writtern by Erich Gamma, John Vlissides, Ralph Johnson and Richard Helm (these authors are known as Gang of Four and so the common abbreviation GoF book :) )
    One problem while studying this book as a Java developer is that the authors are using C++ to demonstrate a pattern, which was the most popular & widely used programming language at the time. So you'll see examples using C++ language features like pointers, copy constructors etc. which do not translate easily to Java.
    This course will help greatly in that aspect. We'll study each design pattern using Java to its full potential.


What is covered in this course?

    This course covers SOLID Design Principles and 26 design patterns in all. We'll cover following:

  • SOLID Design Principles: Learn about Single Responsibility, Open-Closed, Liskov substitution, Interface segregation & Dependency Inversion principles.

  • Creational Design Patterns: Simple Factory, Abstract Factory, Factory Method, Singleton, Builder, Prototype & Object Pool

  • Structural Design Patterns: Object & Class Adapters, Decorator, Bridge, Facade, Static & Dynamic Proxy, Flyweight & Composite  

  • Behavioral Design Patterns: Chain of Responsibility, Command, Interpreter, Mediator, Iterator, Memento, Observer, State, Strategy, Template Method, Visitor, & Null Object

    Each design patterns is also implemented in a follow along coding lecture.


How the Course is Structured?

    We focus on live coding along with theory. Each design is implemented in a live coding session (which you can follow along) as well as discussed with UML & slides. After studing a section you'll know almost everything about the design pattern.

    This course is created with focus on being used as a reference. So each design pattern is discussed in it's own section with a separated lecture for each aspect of the design pattern. Each section is organized as following lectures:
    1. Introduction - This lecture introduces pattern, a problem that it solves & a formal UML diagram
    2. Implementation Steps - This lecture will discuss how you'll implement this pattern in Java.
    3. Example UML - We discuss the UML of the hands on problem we're going to solve.
    4. Implementation - In this lecture we'll implement the design pattern in Java using Eclipse IDE
    5. Implementation & Design Considerations - Some important points about performance, variations & practical advice on using the pattern
    6. Real World Example - In this lecture we'll see how the pattern is used in real life by Java's own class library & popular frameworks like Spring, JSF
    7. Comparison with Similar pattern - See how the pattern is different than another similar pattern.
    8. Pitfalls - Many pattern have some drawbacks. This lecture will show you what those are.
    9. Summary - This lecture will summarise all the information about the pattern.

    As you can see, by breaking a single design pattern in smaller topics, you can easily watch only those parts that you need in future.


What is provided with the Course?

  •  We have provided all code samples from the hands on lectures. You can download the starter code & follow along or you can download the finished code to study on your own.

  •  All UML diagram with description of each role in the design pattern is provided as PDF in summary video. These slides are enough to quickly revise design pattern structure.

  • A PDF guide to all design pattern summaries with code samples and UML diagrams.

Who should take this Course?

  • Beginner as well as experience Developers.

  • Software Designers & Architects.

 

Who this course is for:
  • This course will benefit every Java developer, regardless of your experience, you'll find something to use.
  • If you are just beginning your career, then you must take this course. It'll benefit you most
  • If you are working in Java for 1 - 4 years, this course'll help you advance to next stage in your career
  • If you are preparing for interview, this course is a must for you.
  • If you are experience developer, this course will help you brush up your software design skills