Java Design Patterns & SOLID Design Principles

17h 5m 6s
English
Paid
April 12, 2024
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.  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.
More
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 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.

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
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

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

Watch Online Java Design Patterns & SOLID Design Principles

Join premium to watch
Go to premium
# Title Duration
1 Section Introduction 01:07
2 Single Responsibility Principle 03:43
3 Single Responsibility Principle - Hands on 12:29
4 Open-Closed Principle 02:29
5 Open-Closed Principle - Hands On 10:40
6 Liskov Substitution Principle 01:36
7 Liskov Substitution Principle - Hands On 10:55
8 Interface Segregation Principle 02:21
9 Interface Segregation Principle - Hands On 07:53
10 Dependency Inversion Principle 07:44
11 Dependency Inversion Principle - Hands On 09:28
12 Design Patterns - Introduction 02:00
13 Creational Patterns - Introduction 01:42
14 Builder - Introduction 06:50
15 Builder Implementation Steps 01:58
16 Builder - Example UML 01:47
17 Builder - Implementation Part 1 14:14
18 Builder - Implementation Part 2 03:46
19 Builder - Implementation & Design Considerations 03:07
20 Builder - Examples 03:40
21 Builder - Comparison with Prototype 03:00
22 Builder - Pitfalls 02:07
23 Builder - Summary 04:55
24 Simple Factory - Introduction 02:36
25 Simple Factory - Implementation Steps 00:50
26 Simple Factory - Implementation 04:23
27 Simple Factory - Implementation & Design Considerations 01:13
28 Simple Factory - Example 01:24
29 Simple Factory - Comparison with Factory Method 00:54
30 Simple Factory - Pitfalls 00:43
31 Simple Factory - Summary 01:38
32 Factory Method - Introduction 02:27
33 Factory Method - Implementation Steps 01:01
34 Factory Method - Example UML 01:36
35 Factory Method - Implementation 06:03
36 Factory Method - Implementation & Design Considerations 02:13
37 Factory Method - Example 02:02
38 Factory Method - Pitfalls 00:55
39 Factory Method - Summary 04:57
40 Prototype - Introduction 02:13
41 Prototype - Implementation Steps 02:04
42 Prototype - Example UML 00:59
43 Prototype - Implementation 11:35
44 Prototype - Implementation & Design Considerations 02:51
45 Prototype - Example 01:10
46 Prototype - Comparison with Singleton 01:21
47 Prototype - Pitfalls 01:18
48 Prototype - Summary 02:51
49 Abstract Factory - Introduction 09:17
50 Abstract Factory - Implementation Steps 01:35
51 Abstract Factory - Example UML 02:56
52 Abstract Factory - Implementation 09:16
53 Abstract Factory - Implementation & Design Considerations 02:10
54 Abstract Factory - Example 06:06
55 Abstract Factory - Comparison with Factory Method 01:17
56 Abstract Factory - Pitfalls 01:26
57 Abstract Factory - Summary 05:23
58 Singleton - Introduction 01:59
59 Singleton - Implementation Steps 01:55
60 Singleton - Implementation - Eager Singleton 03:40
61 Singleton - Implementation - Lazy Singleton 06:18
62 Singleton - Implementation - Initialization Holder 07:21
63 Singleton - Implementation - Enum 03:00
64 Singleton - Implementation & Design Considerations 03:30
65 Singleton - Example 01:05
66 Singleton - Comparison with Factory Method 01:08
67 Singleton - Pitfalls 02:05
68 Singleton - Summary 09:14
69 Object Pool - Introduction 03:15
70 Object Pool - Implementation Steps 01:35
71 Object Pool - Example UML 02:05
72 Object Pool - Implementation 15:52
73 Object Pool - Implementation & Design Considerations 04:53
74 Object Pool - Example 03:59
75 Object Pool - Comparison with Prototype 01:18
76 Object Pool - Pitfalls 02:07
77 Object Pool - Summary 07:16
78 Structural Design Patterns - Introduction 01:57
79 Adapter - Introduction 05:36
80 Adapter - Implementation Steps 02:26
81 Adapter - Example UML 02:00
82 Adapter - Implementation - Class Adapter 06:19
83 Adapter - Implementation - Object Adapter 05:02
84 Adapter - Implementation & Design Considerations 03:52
85 Adapter - Example 01:36
86 Adapter - Comparison with Decorator 02:11
87 Adapter - Pitfalls 02:44
88 Adapter - Summary 05:11
89 Bridge - Introduction 05:14
90 Bridge - Implementation Steps 03:00
91 Bridge - Example UML 03:19
92 Bridge - Implementation 06:00
93 Bridge - Implementation & Design Considerations 02:11
94 Bridge - Example 04:31
95 Bridge - Comparison with Adapter 01:49
96 Bridge - Pitfalls 01:12
97 Bridge - Summary 04:00
98 Decorator - Introduction 02:30
99 Decorator - Implementation Steps 01:17
100 Decorator - Example UML 01:55
101 Decorator - Implementation 06:35
102 Decorator - Implementation & Design Considerations 03:24
103 Decorator - Example 01:47
104 Decorator - Comparison with Composite 01:11
105 Decorator - Pitfalls 01:50
106 Decorator - Summary 03:23
107 Composite - Introduction 05:24
108 Composite - Implementation Steps 01:56
109 Composite - Example UML 01:18
110 Composite - Implementation 09:48
111 Composite - Implementation & Design Considerations 03:22
112 Composite - Example 02:10
113 Composite - Comparison with Decorator 01:03
114 Composite - Pitfalls 01:41
115 Composite - Summary 04:38
116 Facade - Introduction 03:13
117 Facade - Implementation Steps 01:32
118 Facade - Example UML 01:19
119 Facade - Implementation 04:18
120 Facade - Implementation & Design Considerations 03:20
121 Facade - Example 03:51
122 Facade - Comparison with Adapter 01:53
123 Facade - Pitfalls 01:40
124 Facade - Summary 02:54
125 Flyweight - Introduction 05:51
126 Flyweight - Implementation Steps 01:57
127 Flyweight - Example UML 02:43
128 Flyweight - Implementation 14:27
129 Flyweight - Implementation & Design Considerations 01:28
130 Flyweight - Example 04:12
131 Flyweight - Comparison with Object Pool 01:22
132 Flyweight - Pitfalls 01:42
133 Flyweight - Summary 05:45
134 Proxy - Introduction 03:32
135 Proxy - Implementation Steps Part 1 02:01
136 Proxy - Example UML 01:36
137 Proxy - Implementation Part 1 09:56
138 Proxy - Dynamic Proxy Implementation Steps 01:20
139 Proxy - Dynamic Proxy Implementation 16:11
140 Proxy - Implementation & Design Considerations 02:55
141 Proxy - Example 01:36
142 Proxy - Comparison with Decorator 01:33
143 Proxy - Pifalls 02:18
144 Proxy - Summary 06:08
145 Behavioral Patterns - Introduction 01:18
146 Chain of Responsibility - Introduction 04:16
147 Chain of Responsibility - Implementation Steps 02:11
148 Chain of Responsibility - Example UML 02:21
149 Chain of Responsibility - Implementation 20:19
150 Chain of Responsibility - Implementation & Design Considerations 02:43
151 Chain of Responsibility - Example 01:50
152 Chain of Responsibility - Comparison with Command 02:07
153 Chain of Responsibility - Pitfalls 01:16
154 Chain of Responsibility - Summary 07:07
155 Command - Introduction 05:20
156 Command - Implementation Steps 03:16
157 Command - Example UML 02:36
158 Command - Implementation 12:47
159 Command - Implementation & Design Considerations 04:22
160 Command - Example 01:32
161 Command - Comparison with Strategy 01:18
162 Command - Pitfalls 03:01
163 Command - Summary 04:29
164 Interpreter - Introduction 04:49
165 Interpreter - Implementation Steps 03:19
166 Interpreter - Example UML 03:14
167 Interpreter - Implementation 21:19
168 Interpreter - Implementation & Design Considerations 03:31
169 Interpreter - Example 03:14
170 Interpreter - Comparison with Visitor 01:19
171 Interpreter - Pitfalls 01:06
172 Interpreter - Summary 04:35
173 Mediator - Introduction 07:12
174 Mediator - Implementation Steps 02:50
175 Mediator - Example UML 05:15
176 Mediator - Implementation 19:31
177 Mediator - Implementation & Design Considerations 03:34
178 Mediator - Example 05:05
179 Mediator - Comparison with Observer 02:38
180 Mediator - Pitfalls 01:09
181 Mediator - Summary 08:21
182 Iterator - Introduction 03:58
183 Iterator - Implementation Steps 02:21
184 Iterator - Example UML 01:50
185 Iterator - Implementation 07:01
186 Iterator - Implementation & Design Considerations 02:54
187 Iterator - Example 01:43
188 Iterator - Pitfalls 01:03
189 Iterator - Summary 05:17
190 Memento - Introduction 03:51
191 Memento - Implementation Steps 01:33
192 Memento - Example UML 03:00
193 Memento - Implementation 17:58
194 Memento - Implementation & Design Considerations 04:14
195 Memento - Example 03:51
196 Memento - Comparison with Command 02:19
197 Memento - Pitfalls 01:00
198 Memento - Summary 05:08
199 Observer - Introduction 06:26
200 Observer - Implementation Steps 02:11
201 Observer - Example UML 01:35
202 Observer - Implementation 14:51
203 Observer - Implementation & Design Considerations 06:39
204 Observer - Example 02:58
205 Observer - Comparison with Mediator 02:12
206 Observer - Pitfalls 01:44
207 Observer - Summary 05:48
208 State - Introduction 04:21
209 State - Implementation Steps 02:33
210 State - Example UML 01:41
211 State - Implementation 15:55
212 State - Implementation & Design Considerations 03:23
213 State - Example 01:47
214 State - Comparison with Command 01:12
215 State - Pitfalls 01:31
216 State - Summary 06:11
217 Strategy - Introduction 03:14
218 Strategy - Implementation Steps 01:35
219 Strategy - Example UML 01:53
220 Strategy - Implementation 10:32
221 Strategy - Implementation & Design Considerations 03:09
222 Strategy - Example 03:23
223 Strategy - Comparison with State 01:05
224 Strategy - Pitfalls 00:50
225 Strategy - Summary 05:45
226 Template Method - Introduction 04:41
227 Template Method - Implementation Steps 01:37
228 Template Method - Example UML 01:43
229 Template Method - Implementation 15:37
230 Template Method - Implementation & Design Considerations 02:38
231 Template Method - Example 01:06
232 Template Method - Comparison with Strategy 01:47
233 Template Method - Pitfalls 01:38
234 Template Method - Summary 03:59
235 Visitor - Introduction 07:15
236 Visitor - Implementation Steps 01:52
237 Visitor - Example UML 03:33
238 Visitor - Implementation 19:07
239 Visitor - Implementation & Design Considerations 04:30
240 Visitor - Example 01:46
241 Visitor - Comparison with Strategy 01:50
242 Visitor - Pitfalls 02:23
243 Visitor - Summary 08:32
244 Null Object - Introduction 04:19
245 Null Object - Implementation Steps 02:05
246 Null Object - Example UML 01:14
247 Null Object - Implementation 06:14
248 Null Object - Implementation & Design Considerations 04:15
249 Null Object - Example 01:46
250 Null Object - Comparison with Proxy 02:17
251 Null Object - Pitfalls 02:23
252 Null Object - Summary 03:40

Similar courses to Java Design Patterns & SOLID Design Principles

Cats

Catsrockthejvm.com

Duration 10 hours 39 minutes 36 seconds
Learn Blockchain Technology & Cryptocurrency in Java

Learn Blockchain Technology & Cryptocurrency in Javaudemy

Duration 5 hours 44 minutes 32 seconds
Java Design Patterns

Java Design Patternsjavaspecialists.eu

Duration 16 hours 20 minutes 37 seconds
Java Generics

Java Genericsamigoscode (Nelson Djalo)

Duration 1 hour 8 minutes 39 seconds