The Java Design Patterns Course

The Java Design Patterns Course

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.

Requirements

You should have a general understanding of Java – ideally by going through this channels Java Crash Course or Java Masterclass
A Windows computer, Linux machine, or a Mac so that the free IDE can be downloaded and install (full instructions included).
An open mind to learn something new and exciting which may make a huge difference in your future career.

Description

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!

Overview

Section 1: Introduction

Lecture 1 Welcome to Class!

Lecture 2 Class Organization

Lecture 3 Overview

Lecture 4 Advantages of Design Patterns

Lecture 5 Types of Design Patterns

Lecture 6 Selecting and Using Design Patterns

Section 2: Installing Required Software

Lecture 7 Install JDK for Windows

Lecture 8 Installing and Configuring IntelliJ IDEA on Windows

Lecture 9 Installing JDK 11 on a Mac

Lecture 10 Installing and Configuring IntelliJ IDEA on a Mac

Lecture 11 Installing JDK 11 on a Linux Machine

Lecture 12 Installing and Configuring IntelliJ IDEA on a Linux Machine

Section 3: Principles and Strategies of Design

Lecture 13 Overview

Lecture 14 Design Smells

Lecture 15 Programming to an interface

Lecture 16 Using Composition Over Inheritance

Lecture 17 Delegation Principles

Lecture 18 The Single Responsibility Principle

Lecture 19 The Open Closed Principle

Lecture 20 The Liskov Substitution Principle

Lecture 21 The Interface Segregation Principle

Lecture 22 Dependency Inversion

Lecture 23 Dependency Injection

Section 4: UML

Lecture 24 Overview

Lecture 25 Class Diagrams

Lecture 26 Drawing a Class Diagram

Lecture 27 Example Class Diagrams

Section 5: Creational Design Patterns

Lecture 28 Overview

Section 6: Factory Method

Lecture 29 Overview

Lecture 30 Implementation (Abstract Creator)

Lecture 31 Implementation (Concrete Creator)

Lecture 32 Implementation (Static Method Creator)

Lecture 33 (Challenge) Factory Method

Lecture 34 (Challenge Solution) Factory Method

Section 7: Abstract Factory Method

Lecture 35 Overview

Lecture 36 Implementation

Lecture 37 (Challenge) Abstract Factory Method

Lecture 38 (Challenge Solution) Abstract Factory Method

Section 8: Singleton

Lecture 39 Overview

Lecture 40 Singleton vs. Dependency Injection

Lecture 41 Implementation Overview

Lecture 42 Implementation (Lazy Evaluation)

Lecture 43 Implementation (Synchronized method)

Lecture 44 Implementation (Double Checked Locking)

Lecture 45 Implementation (Eager Evaluation)

Lecture 46 Implementation (Bill Pugh)

Lecture 47 (Challenge) Singleton

Lecture 48 (Challenge Solution) Singleton

Section 9: Builder

Lecture 49 Overview

Lecture 50 Implementation (Overview)

Lecture 51 Implementation (Example)

Lecture 52 (Challenge) Builder

Lecture 53 (Challenge Solution) Builder

Section 10: Prototype

Lecture 54 Overview

Lecture 55 Implementation

Lecture 56 Problems with the Cloneable Interface

Lecture 57 (Challenge) Prototype

Lecture 58 (Challenge Solution) Prototype

Section 11: Structural Design Patterns

Lecture 59 Overview

Section 12: Adapter

Lecture 60 Overview

Lecture 61 Object Adapter Implementation

Lecture 62 Object Adapter (Turkey/Duck Example)

Lecture 63 Object Adapter (Calculator/Triangle Example)

Lecture 64 Class Adapter Implementation

Lecture 65 ClassAdapter Example

Lecture 66 (Challenge) Adapter

Lecture 67 (Challenge Solution) Adapter

Section 13: Bridge

Lecture 68 Overview

Lecture 69 Implementation (Overview)

Lecture 70 Implementation (Example)

Lecture 71 (Challenge) Bridge

Lecture 72 (Challenge Solution) Bridge

Section 14: Composite

Lecture 73 Overview

Lecture 74 Implementation (Overview)

Lecture 75 Implementation (Example)

Lecture 76 (Challenge) Composite

Lecture 77 (Challenge Solution) Composite

Section 15: Decorator

Lecture 78 Overview

Lecture 79 Implementation (Overview)

Lecture 80 Implementation (File I/O Example)

Lecture 81 (Challenge) Decorator

Lecture 82 (Challenge Solution) Decorator

Section 16: Facade

Lecture 83 Overview

Lecture 84 Implementation (Overview)

Lecture 85 Implementation (Example)

Lecture 86 (Challenge) Facade

Lecture 87 (Challenge Solution) Facade

Section 17: Flyweight

Lecture 88 Overview

Lecture 89 Implementation (Overview)

Lecture 90 Implementation (Example)

Lecture 91 (Challenge) Flyweight

Lecture 92 (Challenge Solution) Flyweight

Section 18: Proxy

Lecture 93 Overview

Lecture 94 Implementation

Lecture 95 (Challenge) Proxy

Lecture 96 (Challenge Solution) Proxy

Section 19: Structural Patterns Summary

Lecture 97 Summary

Section 20: Behavioral Design Patterns

Lecture 98 Overview

Section 21: Chain of Responsibility

Lecture 99 Overview

Lecture 100 Implementation

Lecture 101 (Challenge) Chain of Responsibility

Lecture 102 (Challenge Solution) Chain of Responsibility

Section 22: Command

Lecture 103 Overview

Lecture 104 Implementation (Overview)

Lecture 105 Implementation (Example)

Lecture 106 (Challenge) Command

Lecture 107 (Challenge Solution) Command

Section 23: Interpreter

Lecture 108 Overview

Lecture 109 Implementation

Lecture 110 (Challenge) Interpreter

Lecture 111 (Challenge Solution) Interpreter

Section 24: Iterator

Lecture 112 Overview

Lecture 113 Implementation

Lecture 114 (Challenge) Iterator

Lecture 115 (Challenge Solution) Iterator

Section 25: Mediator

Lecture 116 Overview

Lecture 117 Implementation (Overview)

Lecture 118 Implementation (Example)

Lecture 119 (Challenge) Mediator

Lecture 120 (Challenge Solution) Mediator

Section 26: Memento

Lecture 121 Overview

Lecture 122 Implementation (Overview)

Lecture 123 Implementation (Example)

Lecture 124 (Challenge) Memento

Lecture 125 (Challenge Solution) Memento

Section 27: Observer

Lecture 126 Overview

Lecture 127 Implementation (Overview)

Lecture 128 java.util Implementation

Lecture 129 Implementation (Example)

Lecture 130 (Challenge) Observer

Lecture 131 (Challenge Solution) Observer

Section 28: State

Lecture 132 Overview

Lecture 133 Implementation (Overview)

Lecture 134 Implementation (Example)

Lecture 135 (Challenge) State

Lecture 136 (Challenge Solution) State

Section 29: Strategy

Lecture 137 Overview

Lecture 138 Implementation (Overview)

Lecture 139 Implementation (Example)

Lecture 140 (Challenge) Strategy

Lecture 141 (Challenge Solution) Strategy

Section 30: Template Method

Lecture 142 Overview

Lecture 143 Implementation (Overview)

Lecture 144 Implementation (Example)

Lecture 145 (Challenge) Template Method

Lecture 146 (Challenge Solution) Template Method

Section 31: Visitor

Lecture 147 Overview

Lecture 148 Implementation (Overview)

Lecture 149 Implementation (Example)

Lecture 150 (Challenge) Visitor

Lecture 151 (Challenge Solution) Visitor

Section 32: Summary of Behavioral Patterns

Lecture 152 Summary of Behavioral Patterns

Section 33: MVC – Model View Controller

Lecture 153 Overview

Section 34: J2EE Patterns

Lecture 154 Overview

Section 35: Conclusion

Lecture 155 Course Summary

Section 36: Extra Information – Source code, and other stuff

Lecture 156 Source Codes

Lecture 157 Bonus Lecture and Information

If you are a beginner programmer, then this course is probably not for you. In that scenario consider taking a Java or C# crash course from this channel.,Programmers who have a reasonable understanding of the basics of Java, ready to take their skills to new levels.,Existing Java programmers who want to obtain skills in Design Patterns to move into more senior programming positions.

Course Information:

Udemy | English | 23h 57m | 8.92 GB
Created by: Tim Buchalka’s Learn Programming Academy

You Can See More Courses in the Developer >> Greetings from CourseDown.com