Design Patterns in Java – Concepts & Hands On Projects

Design Patterns in Java – Concepts & Hands On Projects
Design Patterns in Java – Concepts & Hands On Projects

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 16 Hours | 1.56 GB
eLearning | Skill level: All Levels


Learn 26 Design Patterns with hands on projects in Java

This course provides a comprehensive introduction to Design patterns in Java with practical hands on exercises. To learn about the design patterns using Java programming language we’ll discuss:

  • Learn what kind of problems are solved by a design pattern.
  • Discuss various roles in the design pattern.
  • Discuss how the 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.
  • Discuss how the design pattern varies from another similar pattern.
  • See where a design pattern is used in real life.

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

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 language to its full potential.

What is covered in this course?
This course covers 26 design patterns in all. We’ll cover following design patterns:

  • 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.
+ Table of Contents

Introduction
1 Design Patterns – Introduction

Creational Design Patterns
2 Creational Patterns – Introduction

Builder
3 Builder – Introduction
4 Builder – Summary
5 Builder Implementation Steps
6 Builder – Example UML
7 Builder – Implementation Part 1
8 Builder – Implementation Part 2
9 Builder – Implementation & Design Considerations
10 Builder – Examples
11 Builder – Comparison with Prototype
12 Builder – Pitfalls

Simple Factory
13 Simple Factory – Introduction
14 Simple Factory – Implementation Steps
15 Simple Factory – Implementation
16 Simple Factory – Implementation & Design Considerations
17 Simple Factory – Example
18 Simple Factory – Comparison with Factory Method
19 Simple Factory – Pitfalls
20 Simple Factory – Summary

Factory Method
21 Factory Method – Introduction
22 Factory Method – Implementation Steps
23 Factory Method – Example UML
24 Factory Method – Implementation
25 Factory Method – Implementation & Design Considerations
26 Factory Method – Example
27 Factory Method – Pitfalls
28 Factory Method – Summary

Prototype
29 Prototype – Introduction
30 Prototype – Implementation Steps
31 Prototype – Example UML
32 Prototype – Implementation
33 Prototype – Implementation & Design Considerations
34 Prototype – Example
35 Prototype – Comparison with Singleton
36 Prototype – Pitfalls
37 Prototype – Summary

Abstract Factory
38 Abstract Factory – Introduction
39 Abstract Factory – Implementation Steps
40 Abstract Factory – Example UML
41 Abstract Factory – Implementation
42 Abstract Factory – Implementation & Design Considerations
43 Abstract Factory – Example
44 Abstract Factory – Comparison with Factory Method
45 Abstract Factory – Pitfalls
46 Abstract Factory – Summary

Singleton
47 Singleton – Introduction
48 Singleton – Pitfalls
49 Singleton – Summary
50 Singleton – Implementation Steps
51 Singleton – Implementation – Eager Singleton
52 Singleton – Implementation – Lazy Singleton
53 Singleton – Implementation – Initialization Holder
54 Singleton – Implementation – Enum
55 Singleton – Implementation & Design Considerations
56 Singleton – Example
57 Singleton – Comparison with Factory Method

Object Pool
58 Object Pool – Introduction
59 Object Pool – Implementation Steps
60 Object Pool – Example UML
61 Object Pool – Implementation
62 Object Pool – Implementation & Design Considerations
63 Object Pool – Example
64 Object Pool – Comparison with Prototype
65 Object Pool – Pitfalls
66 Object Pool – Summary

Structural Design Patterns
67 Structural Design Patterns – Introduction

Adapter
68 Adapter – Introduction
69 Adapter – Summary
70 Adapter – Implementation Steps
71 Adapter – Example UML
72 Adapter – Implementation – Class Adapter
73 Adapter – Implementation – Object Adapter
74 Adapter – Implementation & Design Considerations
75 Adapter – Example
76 Adapter – Comparison with Decorator
77 Adapter – Pitfalls

Bridge
78 Bridge – Introduction
79 Bridge – Implementation Steps
80 Bridge – Example UML
81 Bridge – Implementation
82 Bridge – Implementation & Design Considerations
83 Bridge – Example
84 Bridge – Comparison with Adapter
85 Bridge – Pitfalls
86 Bridge – Summary

Decorator
87 Decorator – Introduction
88 Decorator – Implementation Steps
89 Decorator – Example UML
90 Decorator – Implementation
91 Decorator – Implementation & Design Considerations
92 Decorator – Example
93 Decorator – Comparison with Composite
94 Decorator – Pitfalls
95 Decorator – Summary

Composite
96 Composite – Introduction
97 Composite – Implementation Steps
98 Composite – Example UML
99 Composite – Implementation
100 Composite – Implementation & Design Considerations
101 Composite – Example
102 Composite – Comparison with Decorator
103 Composite – Pitfalls
104 Composite – Summary

Facade
105 Facade – Introduction
106 Facade – Implementation Steps
107 Facade – Example UML
108 Facade – Implementation
109 Facade – Implementation & Design Considerations
110 Facade – Example
111 Facade – Comparison with Adapter
112 Facade – Pitfalls
113 Facade – Summary

Flyweight
114 Flyweight – Introduction
115 Flyweight – Implementation Steps
116 Flyweight – Example UML
117 Flyweight – Implementation
118 Flyweight – Implementation & Design Considerations
119 Flyweight – Example
120 Flyweight – Comparison with Object Pool
121 Flyweight – Pitfalls
122 Flyweight – Summary

Proxy
123 Proxy – Introduction
124 Proxy – Pifalls
125 Proxy – Summary
126 Proxy – Implementation Steps Part 1
127 Proxy – Example UML
128 Proxy – Implementation Part 1
129 Proxy – Dynamic Proxy Implementation Steps
130 Proxy – Dynamic Proxy Implementation
131 Proxy – Implementation & Design Considerations
132 Proxy – Example
133 Proxy – Comparison with Decorator

Behavioral Design Patterns
134 Behavioral Patterns – Introduction

Chain of Responsibility
135 Chain of Responsibility – Introduction
136 Chain of Responsibility – Implementation Steps
137 Chain of Responsibility – Example UML
138 Chain of Responsibility – Implementation
139 Chain of Responsibility – Implementation & Design Considerations
140 Chain of Responsibility – Example
141 Chain of Responsibility – Comparison with Command
142 Chain of Responsibility – Pitfalls
143 Chain of Responsibility – Summary

Command
144 Command – Introduction
145 Command – Implementation Steps
146 Command – Example UML
147 Command – Implementation
148 Command – Implementation & Design Considerations
149 Command – Example
150 Command – Comparison with Strategy
151 Command – Pitfalls
152 Command – Summary

Interpreter
153 Interpreter – Introduction
154 Interpreter – Implementation Steps
155 Interpreter – Example UML
156 Interpreter – Implementation
157 Interpreter – Implementation & Design Considerations
158 Interpreter – Example
159 Interpreter – Comparison with Visitor
160 Interpreter – Pitfalls
161 Interpreter – Summary

Mediator
162 Mediator – Introduction
163 Mediator – Implementation Steps
164 Mediator – Example UML
165 Mediator – Implementation
166 Mediator – Implementation & Design Considerations
167 Mediator – Example
168 Mediator – Comparison with Observer
169 Mediator – Pitfalls
170 Mediator – Summary

Iterator
171 Iterator – Introduction
172 Iterator – Implementation Steps
173 Iterator – Example UML
174 Iterator – Implementation
175 Iterator – Implementation & Design Considerations
176 Iterator – Example
177 Iterator – Pitfalls
178 Iterator – Summary

Memento
179 Memento – Introduction
180 Memento – Implementation Steps
181 Memento – Example UML
182 Memento – Implementation
183 Memento – Implementation & Design Considerations
184 Memento – Example
185 Memento – Comparison with Command
186 Memento – Pitfalls
187 Memento – Summary

Observer
188 Observer – Introduction
189 Observer – Implementation Steps
190 Observer – Example UML
191 Observer – Implementation
192 Observer – Implementation & Design Considerations
193 Observer – Example
194 Observer – Comparison with Mediator
195 Observer – Pitfalls
196 Observer – Summary

State
197 State – Introduction
198 State – Implementation Steps
199 State – Example UML
200 State – Implementation
201 State – Implementation & Design Considerations
202 State – Example
203 State – Comparison with Command
204 State – Pitfalls
205 State – Summary

Strategy
206 Strategy – Introduction
207 Strategy – Implementation Steps
208 Strategy – Example UML
209 Strategy – Implementation
210 Strategy – Implementation & Design Considerations
211 Strategy – Example
212 Strategy – Comparison with State
213 Strategy – Pitfalls
214 Strategy – Summary

Template Method
215 Template Method – Introduction
216 Template Method – Implementation Steps
217 Template Method – Example UML
218 Template Method – Implementation
219 Template Method – Implementation & Design Considerations
220 Template Method – Example
221 Template Method – Comparison with Strategy
222 Template Method – Pitfalls
223 Template Method – Summary

Visitor
224 Visitor – Introduction
225 Visitor – Implementation Steps
226 Visitor – Example UML
227 Visitor – Implementation
228 Visitor – Implementation & Design Considerations
229 Visitor – Example
230 Visitor – Comparison with Strategy
231 Visitor – Pitfalls
232 Visitor – Summary

Null Object
233 Null Object – Introduction
234 Null Object – Implementation Steps
235 Null Object – Example UML
236 Null Object – Implementation
237 Null Object – Implementation & Design Considerations
238 Null Object – Example
239 Null Object – Comparison with Proxy
240 Null Object – Pitfalls
241 Null Object – Summary


Download from Turbobit

Download from DepositFiles

Download from Rapidgator