Java Design Patterns & SOLID Design Principles
More
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.
- 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
- 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
| # | 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
Experience Design Patterns In Java
Algorithms in Java: Live problem solving & Design Techniques
RESTful Web Services, Java, Spring Boot, Spring MVC and JPA
Building Your First App with Spring Boot and Angular
Data Structures and Algorithms: Deep Dive Using Java
Java Messaging Service - Spring MVC, Spring Boot, ActiveMQ
Java Master Class
Data Structures & Algorithms !
