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

Java Design Patterns & SOLID Design Principles is a 252-lesson 17 hours 5 minutes self-paced course by Udemy. This course starts with SOLID Design Principles in Java.

Course facts

Lessons: 252
Duration: 17 hours 5 minutes
Level: All levels
Language: English
Updated
Instructor: Udemy
Price: Premium

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

Who teaches Java Design Patterns & SOLID Design Principles? 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.

What lessons are included in Java Design Patterns & SOLID Design Principles?

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

What courses are similar to Java Design Patterns & SOLID Design Principles?

Classic
Java Master Class
By: Nelson Djalo (Amigoscode)
Welcome to Amigoscode's most comprehensive Java course! It includes everything you need to gain a complete understanding of Java.
24h 40m5/5
Updated 2y ago
Cats
By: Rock the JVM
We Scala programmers love abstractions and Cats is one of the most popular libraries. At the same time, Cats is notorious for having a steep learning curve. Fun
10h 39m
Updated 8mo ago
Low Level Design
By: takeUforward (Striver)
The course is dedicated to Low-Level Design (LLD) - a key stage in software development where abstract ideas and architectural decisions are transformed into.
22h 34m
Updated 2y ago
Ultimate Java Part 3: Advanced Topics
By: Mosh Hamedani (Code with Mosh)
Want to level-up your Java skills and reach the advanced level? Want to become an in-demand Java developer for exciting software companies?
6h 28m5/5
Updated 3y ago
Machine Learning with Javascript
By: Udemy, Stephen Grider
If you're here, you already know the truth: Machine Learning is the future of everything.
17h 42m
Updated 2y ago
Java Streams API
By: Nelson Djalo (Amigoscode)
Functional programming is becoming very popular and it focuses around pure functions. Functional applications avoid the shared state, and tend to be more concis
2h 33m
Updated 2y ago
Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka
By: Udemy
Hi there! My name is Ali Gelenler. I'm here to help you learn microservices architecture while applying Clean and Hexagonal Architectures and using Domain Drive
18h 2m
Updated 3y ago
Java Programming Masterclass covering Java 11 & Java 17
By: Udemy
You’ve just stumbled upon the most complete, in-depth Java programming course online. With over 260,000 students enrolled and tens of thousands of 5 star review
80h 13m5/5

More courses by Udemy

New
React - The Complete Guide
React: The Complete Guide by Maximilian Schwarzmüller — original 2022 edition covering React hooks, Redux, Context API, Next.js basics.
47h 42m5/5
Updated 3y ago
Complete C# Unity Game Developer 3D
This is the long-awaited sequel to the Complete Unity Developer - one of the most popular e-learning courses on the internet!
30h 34m
Updated 3y ago
Nest.js Microservices: Build & Deploy a Scaleable Backend
Nest.js is an incredible backend framework that allows us to build scaleable Nodejs backends with very little complexity. A Microservice architecture is a popul
5h 39m5/5
Updated 3y ago
The HTML & CSS Bootcamp 2023 Edition
Brand new HTML & CSS course, just released in February 2023 Check out the promo video to see the beautiful, responsive projects we build in this course!
37h 18m5/5
Updated 3y ago
Microservices with Node JS and React
Event-Based Architecture? Covered! Server side rendering with React? Yep. Scalable, production-ready code? Its here!
54h 13m5/5
FreeClassic
100 Days of Code - The Complete Python Pro Bootcamp for 2023
Watch the 100 Days of Code Python Pro Bootcamp free: 100 daily projects covering Python basics, web scraping, data science, automation and GUI apps.
58h 35m5/5

Frequently asked questions

What prerequisites are needed for this course?

The course assumes familiarity with Java programming. You should understand basic Java syntax and object-oriented programming concepts. Prior exposure to software design principles would be beneficial, but is not required as the course starts with foundational SOLID Design Principles in Java.

What types of projects will I build during the course?

The course includes hands-on exercises for each design pattern and SOLID principle. These projects involve implementing patterns like Builder, Simple Factory, Factory Method, Prototype, Abstract Factory, and Singleton. Each pattern has dedicated lessons that guide you through implementation steps, design considerations, and potential pitfalls.

Who is the target audience for this course?

The course is aimed at Java developers looking to deepen their understanding of design patterns and SOLID principles. It is suitable for both novice and intermediate developers seeking to improve their software design skills and apply these concepts to real-world applications.

How does this course compare in depth and scope to other design pattern courses?

This course offers a comprehensive introduction to both SOLID principles and Java-specific design patterns. It covers all classic patterns from the Gang of Four book and includes newer patterns used in modern development. With 252 lessons, it provides detailed implementation guidance and practical exercises for each pattern.

Are there any specific tools or platforms used in the course?

The course focuses on implementing design patterns using the Java programming language. It does not specify any particular development environment, so you can use your preferred tools and platforms for Java development. Practical exercises will guide you through pattern implementation in Java.

What topics are not covered in the course?

While the course covers SOLID principles and design patterns extensively, it does not delve into other programming languages or non-Java-specific design patterns. It also does not cover advanced topics in Java programming outside the scope of design patterns and principles.

How will the skills learned in this course be valuable in other courses or careers?

Understanding SOLID principles and design patterns enhances your ability to write robust, maintainable, and scalable code. These skills are valuable across various software development roles and can be applied in other programming languages. Mastery of these concepts can significantly benefit your career as a software developer or engineer.