Java Design Patterns & SOLID Design Principles

Java Design Patterns & SOLID Design Principles, available at $94.99, has an average rating of 4.56, with 253 lectures, 28 quizzes, based on 5463 reviews, and has 46918 subscribers.

You will learn about 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 This course is ideal for individuals who are This course will benefit every Java developer, regardless of your experience, you'll find something to use. or If you are just beginning your career, then you must take this course. It'll benefit you most or If you are working in Java for 1 – 4 years, this course'll help you advance to next stage in your career or If you are preparing for interview, this course is a must for you. or If you are experience developer, this course will help you brush up your software design skills It is particularly useful for This course will benefit every Java developer, regardless of your experience, you'll find something to use. or If you are just beginning your career, then you must take this course. It'll benefit you most or If you are working in Java for 1 – 4 years, this course'll help you advance to next stage in your career or If you are preparing for interview, this course is a must for you. or If you are experience developer, this course will help you brush up your software design skills.

Enroll now: Java Design Patterns & SOLID Design Principles

Summary

Title: Java Design Patterns & SOLID Design Principles

Price: $94.99

Average Rating: 4.56

Number of Lectures: 253

Number of Quizzes: 28

Number of Published Lectures: 253

Number of Published Quizzes: 28

Number of Curriculum Items: 281

Number of Published Curriculum Objects: 281

Original Price: $79.99

Quality Status: approved

Status: Live

What You Will 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 Should Attend

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

Target Audiences

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

Course Overview

This course starts with SOLID Design Principlesin Java. It will then provide a comprehensive introduction to Java Design patterns with practical, hands on exercises.

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 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.

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 Javato 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.

�

Course Curriculum

Chapter 1: SOLID Design Principles

Lecture 1: Section Introduction

Lecture 2: Single Responsibility Principle

Lecture 3: Single Responsibility Principle – Hands on

Lecture 4: Open-Closed Principle

Lecture 5: Open-Closed Principle – Hands On

Lecture 6: Liskov Substitution Principle

Lecture 7: Liskov Substitution Principle – Hands On

Lecture 8: Interface Segregation Principle

Lecture 9: Interface Segregation Principle – Hands On

Lecture 10: Dependency Inversion Principle

Lecture 11: Dependency Inversion Principle – Hands On

Chapter 2: Introduction

Lecture 1: Design Patterns – Introduction

Chapter 3: Creational Design Patterns

Lecture 1: Creational Patterns – Introduction

Chapter 4: Builder

Lecture 1: Builder – Introduction

Lecture 2: Builder Implementation Steps

Lecture 3: Builder – Example UML

Lecture 4: Builder – Implementation Part 1

Lecture 5: Builder – Implementation Part 2

Lecture 6: Builder – Implementation & Design Considerations

Lecture 7: Builder – Examples

Lecture 8: Builder – Comparison with Prototype

Lecture 9: Builder – Pitfalls

Lecture 10: Builder – Summary

Chapter 5: Simple Factory

Lecture 1: Simple Factory – Introduction

Lecture 2: Simple Factory – Implementation Steps

Lecture 3: Simple Factory – Implementation

Lecture 4: Simple Factory – Implementation & Design Considerations

Lecture 5: Simple Factory – Example

Lecture 6: Simple Factory – Comparison with Factory Method

Lecture 7: Simple Factory – Pitfalls

Lecture 8: Simple Factory – Summary

Chapter 6: Factory Method

Lecture 1: Factory Method – Introduction

Lecture 2: Factory Method – Implementation Steps

Lecture 3: Factory Method – Example UML

Lecture 4: Factory Method – Implementation

Lecture 5: Factory Method – Implementation & Design Considerations

Lecture 6: Factory Method – Example

Lecture 7: Factory Method – Pitfalls

Lecture 8: Factory Method – Summary

Chapter 7: Prototype

Lecture 1: Prototype – Introduction

Lecture 2: Prototype – Implementation Steps

Lecture 3: Prototype – Example UML

Lecture 4: Prototype – Implementation

Lecture 5: Prototype – Implementation & Design Considerations

Lecture 6: Prototype – Example

Lecture 7: Prototype – Comparison with Singleton

Lecture 8: Prototype – Pitfalls

Lecture 9: Prototype – Summary

Chapter 8: Abstract Factory

Lecture 1: Abstract Factory – Introduction

Lecture 2: Abstract Factory – Implementation Steps

Lecture 3: Abstract Factory – Example UML

Lecture 4: Abstract Factory – Implementation

Lecture 5: Abstract Factory – Implementation & Design Considerations

Lecture 6: Abstract Factory – Example

Lecture 7: Abstract Factory – Comparison with Factory Method

Lecture 8: Abstract Factory – Pitfalls

Lecture 9: Abstract Factory – Summary

Chapter 9: Singleton

Lecture 1: Singleton – Introduction

Lecture 2: Singleton – Implementation Steps

Lecture 3: Singleton – Implementation – Eager Singleton

Lecture 4: Singleton – Implementation – Lazy Singleton

Lecture 5: Singleton – Implementation – Initialization Holder

Lecture 6: Singleton – Implementation – Enum

Lecture 7: Singleton – Implementation & Design Considerations

Lecture 8: Singleton – Example

Lecture 9: Singleton – Comparison with Factory Method

Lecture 10: Singleton – Pitfalls

Lecture 11: Singleton – Summary

Chapter 10: Object Pool

Lecture 1: Object Pool – Introduction

Lecture 2: Object Pool – Implementation Steps

Lecture 3: Object Pool – Example UML

Lecture 4: Object Pool – Implementation

Lecture 5: Object Pool – Implementation & Design Considerations

Lecture 6: Object Pool – Example

Lecture 7: Object Pool – Comparison with Prototype

Lecture 8: Object Pool – Pitfalls

Lecture 9: Object Pool – Summary

Chapter 11: Structural Design Patterns

Lecture 1: Structural Design Patterns – Introduction

Chapter 12: Adapter

Lecture 1: Adapter – Introduction

Instructors

Coffee Powered Crew
Excellence with Elegance to Perfection!

Rating Distribution

1 stars: 56 votes
2 stars: 70 votes
3 stars: 448 votes
4 stars: 1987 votes
5 stars: 2902 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu