Design Patterns and SOLID Principles with Java

Design Patterns and SOLID Principles with Java, available at $39.99, has an average rating of 3.75, with 31 lectures, 6 quizzes, based on 11 reviews, and has 53 subscribers.

You will learn about What design patterns are and why you should learn and use them Understand and apply important design patterns such as the Template Method, the Strategy, the Singleton, the Facade, and the Factory Method Learn about cloud design patterns such as the Strangler, the Circuit Breaker and the Cache-Aside patterns Identify and avoid anti-patterns—for instance, using God objects or having a so-called pattern fetish How and why to design modular and extensible code by exploring important SOLID principles How to quickly refactor code that does not adhere to design best practices by using your favorite IDE This course is ideal for individuals who are This course is for programmers/developers. It is particularly useful for This course is for programmers/developers.

Enroll now: Design Patterns and SOLID Principles with Java

Summary

Title: Design Patterns and SOLID Principles with Java

Price: $39.99

Average Rating: 3.75

Number of Lectures: 31

Number of Quizzes: 6

Number of Published Lectures: 31

Number of Published Quizzes: 6

Number of Curriculum Items: 37

Number of Published Curriculum Objects: 37

Original Price: $109.99

Quality Status: approved

Status: Live

What You Will Learn

What design patterns are and why you should learn and use them
Understand and apply important design patterns such as the Template Method, the Strategy, the Singleton, the Facade, and the Factory Method
Learn about cloud design patterns such as the Strangler, the Circuit Breaker and the Cache-Aside patterns
Identify and avoid anti-patterns—for instance, using God objects or having a so-called pattern fetish
How and why to design modular and extensible code by exploring important SOLID principles
How to quickly refactor code that does not adhere to design best practices by using your favorite IDE

Who Should Attend

This course is for programmers/developers.

Target Audiences

This course is for programmers/developers.

This course will guide you through the whys and hows of important design patterns using SOLID principles and, more importantly, will help you recognize opportunities to apply these; its focus is on real-world problems and down-to-earth explanations to get you started quickly. The goal of the course is not to have you breeze through every design pattern in existence in a few minutes with oversimplified examples. Instead, you will learn selected design patterns in an in-depth way. During the course, you’ll also familiarize yourself with the major aspects of SOLID design and writing clean code, as these concepts and applying design patterns should go hand-in-hand.

By the end of the course, you will be able to identify (and confidently apply) design patterns in your own applications and be empowered to make your design choices using complex examples.

About the Author

Róbert Kohányi is software developer, mentor, and full-stack developer based in Hungary with 10 years’ experience developing Java backend applications for the corporate sector. He currently works as a mentor helping junior developers learn the ropes when it comes to IT and bringing out their full potential.

Course Curriculum

Chapter 1: Design Patterns Quickstart with Template Methods

Lecture 1: The Course Overview

Lecture 2: Quick Overview of Design Patterns

Lecture 3: Exploring the Sample Code, Introducing Future Requirements

Lecture 4: Understanding and Using Template Methods

Lecture 5: Pros and Cons of Template Methods

Lecture 6: Favoring Composition over Inheritance

Chapter 2: Quick Prototyping with the Singleton Pattern

Lecture 1: Introduction to the Singleton Pattern

Lecture 2: New Requirements and Prototyping

Lecture 3: Data Access Layer with Singletons

Lecture 4: Using Singletons the Right Way

Lecture 5: Singleton Alternatives

Chapter 3: Maintainable Code with the Strategy Pattern

Lecture 1: Introduction to the Strategy Pattern

Lecture 2: Strategy for Changing Requirements

Lecture 3: Making SOLID Strategies

Lecture 4: Dynamic Strategy

Lecture 5: Strategy versus Template

Chapter 4: Dependency Management with the Factory Pattern

Lecture 1: Introduction to “Simple” Factory

Lecture 2: Object Creation with the Factory Method

Lecture 3: Abstract Factory and Dependency Inversion

Lecture 4: Factory to Build a “Family”

Lecture 5: Dynamic Dependencies

Chapter 5: Hiding Complexity with Facades

Lecture 1: Introduction to Facades

Lecture 2: Hiding Behind Facades

Lecture 3: Flexible Subsystems

Lecture 4: Microservices and Facades

Lecture 5: SOLID Facade Design

Chapter 6: Design Patterns in the Cloud

Lecture 1: Cloud Migration

Lecture 2: Local and Cloud Environments

Lecture 3: From Monolith to Microservices

Lecture 4: Patterns for Resilience and Scalability

Lecture 5: Summary and Next Steps

Instructors

Packt Publishing
Tech Knowledge in Motion

Rating Distribution

1 stars: 0 votes
2 stars: 2 votes
3 stars: 4 votes
4 stars: 4 votes
5 stars: 1 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