Java Design Patterns & SOLID Design Principles

Name: Java Design Patterns & SOLID Design Principles
Price: 12.75 USD
Availability: InStock

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.

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

About the Author: Udemy

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 252 lessons

0:00

#1: Section Introduction

All Course Lessons (252)

#	Lesson Title	Duration
1	Section Introduction Demo	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

Unlock unlimited learning

Get instant access to all 251 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Course content

252 lessons · 17h 5m 6s

Show all 252 lessons

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

Related courses

Java Puzzles to Eliminate Code Fear
By: Udemy
The motivation behind this course came from an article titled "Why Can't Programmers Program?" by Jeff Atwood. It talks about how poorly many candidates perform
7 hours 33 minutes 44 seconds
Learn Java Unit Testing with Junit & Mockito in 30 Steps
By: Udemy
Learn Mockito and JUnit - the most popular Java unit testing and mocking frameworks - with 25 Examples. Writing Great Unit Tests distinguishes Good Programmers
4 hours 44 minutes 35 seconds
Java Test Automation Engineer - from Zero to Hero
By: Udemy
Are you ready to embark on an exciting journey to become a Test Automation Hero in Java? Whether you're new to programming or have some experience, this course
18 hours 40 minutes 6 seconds

Frequently asked questions

What is Java Design Patterns & SOLID Design Principles about?

Who teaches Java Design Patterns & SOLID Design Principles?

Java Design Patterns & SOLID Design Principles is taught by Udemy. You can find more courses by this instructor on the corresponding source page.

How long is Java Design Patterns & SOLID Design Principles?

Java Design Patterns & SOLID Design Principles contains 252 lessons with a total runtime of 17 hours 5 minutes. All lessons are available to watch online at your own pace.

Is Java Design Patterns & SOLID Design Principles free to watch?

Java Design Patterns & SOLID Design Principles is part of CourseFlix's premium catalog. A CourseFlix subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.

Where can I watch Java Design Patterns & SOLID Design Principles online?

Java Design Patterns & SOLID Design Principles is available to watch online on CourseFlix at https://courseflix.net/course/java-design-patterns-solid-design-principles. The page hosts every lesson with the integrated video player; no download is required.

Java Design Patterns & SOLID Design Principles

About the Author: Udemy

Java Puzzles to Eliminate Code Fear

Learn Java Unit Testing with Junit & Mockito in 30 Steps

Java Test Automation Engineer - from Zero to Hero