**The Java Design Patterns Course**

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 24 Hours | 10.0 GB

Understand the how and the why of the gang of four design patterns using Java.

So you have some Java experience under your belt, but are trying to figure out what to do next to make it easier to get that next job or consulting gig, and to stand out from the crowd.

Maybe you have heard of design patterns before and have seen programmers who know them and are able to implement them are held in very high regard.

One thing is clear, Java programmers with design pattern experience are in high demand. Design patterns are heavily used in the real world, so it’s essential that Java programmers learn how to identify design patterns and implement them.

And that’s what you are going to learn in this course!

Perhaps you tried to learn about design patterns in the past, but struggled to understand them. This course is going to give you the core design patterns experience you need!

This course is unique in comparison to other design patterns courses.

Why? It not only teaches how to use design patterns, but perhaps more importantly, it teaches why you should use them! Why they are the best approach and how using them can make you a super productive and awesome Java Programmer.

The reality is that Java developers who truly understand how to use design patterns are in high demand.

So what specifically is included in this course?

This course focuses on the details and a thorough understanding of all design patterns from the Gang of four.

Who are the Gang of four?

Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides released a book in 1994 that was and is still considered a classic. The concepts are still very relevant in 2019!

This course is all about showing you how to use their design patterns in todays software development environment.

You will learn detailed aspects of common design patterns (23 from the Gang of four) using the Java programming language.

Why should I bother with Design Patterns?

In programming terms, a design pattern is a solution to a common problem that occurs when writing software. Think of it as more like a template than actual code – its a how-to to solve a problem that can be re-used in many different situations.

Using design patterns gives you a way to solve common problems with a proven solution! So learning java design patterns and architecture and being able to use and implement them are critical to take your Java programming to new levels.

What you will learn in this course.

You will learn how to implement specific design patterns in addition to learning why they are the best approach and how they make you a super productive and awesome Java programmer.

Many, many examples and challenges are provided to test your understanding of every pattern that you have learned.

This course is unique to other courses here at Udemy in that the details and the why are explained. We do not just go through projects and provide a how-to. You will learn WHY you should be using a particular design pattern and the benefits to doing so.

Jason Fedin, you instructor is an expert Java developer, and has one of the most popular C programming languages on Udemy (published on this channel).

As a professional programmer, with over 18 years of commercial experience, you can be assured you are learning from a true professional and learning the real-world skills you need to know to succeed.

If you are ready to get started, click on that enroll button and start taking your Java skills to new levels!

What you’ll learn

- Understand all 23 of the Gang of Four’s design patterns and how to implement them in Java.
- Be able to demonstrate industry best practices in the implementations of Java design patterns code you write.
- Obtain a solid understanding of what design patterns are, how to implement them but also WHY you should!
- Acquired the design patterns skills you need to become a senior Java developer.

**Table of Contents**

**Introduction**

1 Welcome to Class!

2 Class Organization

3 Overview

4 Advantages of Design Patterns

5 Types of Design Patterns

6 Selecting and Using Design Patterns

**Installing Required Software**

7 Install JDK for Windows

8 Installing and Configuring IntelliJ IDEA on Windows

9 Installing JDK 11 on a Mac

10 Installing and Configuring IntelliJ IDEA on a Mac

11 Installing JDK 11 on a Linux Machine

12 Installing and Configuring IntelliJ IDEA on a Linux Machine

**Principles and Strategies of Design**

13 Overview

14 Dependency Inversion

15 Dependency Injection

16 Design Smells

17 Programming to an interface

18 Using Composition Over Inheritance

19 Delegation Principles

20 The Single Responsibility Principle

21 The Open Closed Principle

22 The Liskov Substitution Principle

23 The Interface Segregation Principle

**UML**

24 Overview

25 Class Diagrams

26 Drawing a Class Diagram

27 Example Class Diagrams

**Creational Design Patterns**

28 Overview

**Factory Method**

29 Overview

30 Implementation (Abstract Creator)

31 Implementation (Concrete Creator)

32 Implementation (Static Method Creator)

33 (Challenge) Factory Method

34 (Challenge Solution) Factory Method

**Abstract Factory Method**

35 Overview

36 Implementation

37 (Challenge) Abstract Factory Method

38 (Challenge Solution) Abstract Factory Method

**Singleton**

39 Overview

40 (Challenge Solution) Singleton

41 Singleton vs. Dependency Injection

42 Implementation Overview

43 Implementation (Lazy Evaluation)

44 Implementation (Synchronized method)

45 Implementation (Double Checked Locking)

46 Implementation (Eager Evaluation)

47 Implementation (Bill Pugh)

48 (Challenge) Singleton

**Builder**

49 Overview

50 Implementation (Overview)

51 Implementation (Example)

52 (Challenge) Builder

53 (Challenge Solution) Builder

**Prototype**

54 Overview

55 Implementation

56 Problems with the Cloneable Interface

57 (Challenge) Prototype

58 (Challenge Solution) Prototype

**Structural Design Patterns**

59 Overview

**Adapter**

60 Overview

61 Object Adapter Implementation

62 Object Adapter (TurkeyDuck Example)

63 Object Adapter (CalculatorTriangle Example)

64 Class Adapter Implementation

65 ClassAdapter Example

66 (Challenge) Adapter

67 (Challenge Solution) Adapter

**Bridge**

68 Overview

69 Implementation (Overview)

70 Implementation (Example)

71 (Challenge) Bridge

72 (Challenge Solution) Bridge

**Composite**

73 Overview

74 Implementation (Overview)

75 Implementation (Example)

76 (Challenge) Composite

77 (Challenge Solution) Composite

**Decorator**

78 Overview

79 Implementation (Overview)

80 Implementation (File IO Example)

81 (Challenge) Decorator

82 (Challenge Solution) Decorator

**Facade**

83 Overview

84 Implementation (Overview)

85 Implementation (Example)

86 (Challenge) Facade

87 (Challenge Solution) Facade

**Flyweight**

88 Overview

89 Implementation (Overview)

90 Implementation (Example)

91 (Challenge) Flyweight

92 (Challenge Solution) Flyweight

**Proxy**

93 Overview

94 Implementation

95 (Challenge) Proxy

96 (Challenge Solution) Proxy

**Structural Patterns Summary**

97 Summary

**Behavioral Design Patterns**

98 Overview

**Chain of Responsibility**

99 Overview

100 Implementation

101 (Challenge) Chain of Responsibility

102 (Challenge Solution) Chain of Responsibility

**Command**

103 Overview

104 Implementation (Overview)

105 Implementation (Example)

106 (Challenge) Command

107 (Challenge Solution) Command

**Interpreter**

108 Overview

109 Implementation

110 (Challenge) Interpreter

111 (Challenge Solution) Interpreter

**Iterator**

112 Overview

113 Implementation

114 (Challenge) Iterator

115 (Challenge Solution) Iterator

**Mediator**

116 Overview

117 Implementation (Overview)

118 Implementation (Example)

119 (Challenge) Mediator

120 (Challenge Solution) Mediator

**Memento**

121 Overview

122 Implementation (Overview)

123 Implementation (Example)

124 (Challenge) Memento

125 (Challenge Solution) Memento

**Observer**

126 Overview

127 Implementation (Overview)

128 java.util Implementation

129 Implementation (Example)

130 (Challenge) Observer

131 (Challenge Solution) Observer

**State**

132 Overview

133 Implementation (Overview)

134 Implementation (Example)

135 (Challenge) State

136 (Challenge Solution) State

**Strategy**

137 Overview

138 Implementation (Overview)

139 Implementation (Example)

140 (Challenge) Strategy

141 (Challenge Solution) Strategy

**Template Method**

142 Overview

143 Implementation (Overview)

144 Implementation (Example)

145 (Challenge) Template Method

146 (Challenge Solution) Template Method

**Visitor**

147 Overview

148 Implementation (Overview)

149 Implementation (Example)

150 (Challenge) Visitor

151 (Challenge Solution) Visitor

**Summary of Behavioral Patterns**

152 Summary of Behavioral Patterns

**MVC – Model View Controller**

153 Overview

**J2EE Patterns**

154 Overview

**Conclusion**

155 Course Summary

**Bonus Material**

156 Bonus – Please Watch!

157 Check out Our Other 38 Udemy Courses!

158 Source Codes

Resolve the captcha to access the links!