Software Design Patterns (Java)

Name: Software Design Patterns (Java)
Rating: 4.4 (59 reviews)

Creational, Structural and Behavioral Design Patterns (Java)

Created byEdu Nation

Last updated 6/2023

English

What you'll learn

Design Patterns
OOP
SOLID
Clean Code

Course content

5 sections • 14 lectures • 58m total length

SOLID Principles11:41
Explore the solid principles, starting with single responsibility, open/closed, liskov substitution, interface segregation, and dependency inversion, with concrete examples of class design and refactoring.
Single-Responsibility Principle (SRP)1:48
Apply the single responsibility principle by separating creation and saving into dedicated classes, so each class has a single job to create orders or save them, improving readability and maintainability.
Open–Closed Principle (OCP)3:13
Apply the open–closed principle by refactoring to an interface-based shape design where each shape implements a method to calculate area. Add new shapes like triangle without modifying existing code.
Liskov Substitution Principle (LSP)2:09
Explain the liskov substitution principle by showing that subclasses must be replaceable for their base types without altering correctness, using a withdrawable intermediary to separate withdrawal-enabled accounts from non-withdrawal accounts.
Interface Segregation Principle (ISP)1:41
Explore the interface segregation principle by splitting a broad interface into printer and scanner interfaces to reduce dependencies and increase flexibility, so machines implement only what they need.
Dependency Inversion Principle (DIP)1:41
The lecture explains the interface segregation principle: design smaller, specific interfaces to reduce dependencies and increase flexibility, using printer and scanner interfaces as an example.

Design Pattern Builder7:38
Explore the design pattern builder, showing how a book object with name and pages is constructed dynamically via a static class builder and a build method.
Factory Design Pattern6:05
Explore the factory design pattern by creating personal or business accounts from an abstract account using a factory class that handles owner, account type, and balance.
Singleton Design Pattern5:25
Explore the singleton design pattern, its single-instance approach and anti-pattern risks, including a class with private constructor and get instance, plus an enum-based variant showing the same instance across objects.

Adapter Design Pattern4:19
Explore how the adapter design pattern lets two incompatible classes work together by wrapping an interface around a class, enabling rectangle, circle, and an adapted triangle to draw.
Facade Design Pattern3:24
Examine how the facade design pattern hides complex logic behind a single class, coordinating start and stop engine commands via an enum and a switch-based listener.

Observer Design Pattern4:05
Demonstrates the observer design pattern by modeling a news agency as observable and news channels as observers that update the news via set news and get news.
Strategy Design Pattern4:07
Explore the strategy design pattern to change a discount algorithm at runtime by defining a discount interface and implementing eastern and new year discounts, with tests validating results.

Requirements

No programming experience required

Description

Our comprehensive Java Design Patterns course covers essential creational, structural, and behavioral design patterns, providing you with a solid understanding of their implementation and usage. With a focus on practical examples and hands-on exercises, this course equips you with the knowledge and skills to design robust and maintainable Java applications.

In the creational design patterns section, you'll delve into Singleton, Builder, and Factory patterns. You'll learn how to create single instances, construct complex objects, and encapsulate object creation logic, respectively. Through real-world scenarios and coding exercises, you'll gain proficiency in applying these patterns effectively.

Moving on to structural design patterns, you'll explore the Adapter and Facade patterns. You'll discover how to bridge incompatible interfaces, enabling collaboration between different components. Additionally, you'll master the art of simplifying complex subsystems and providing a unified interface using the Facade pattern.

In the behavioral design patterns segment, you'll dive into Observer and Strategy patterns. You'll understand how to establish one-to-many relationships between objects and implement efficient event handling. Moreover, you'll learn to encapsulate algorithms and dynamically interchange them, enhancing the flexibility and extensibility of your codebase.

Throughout the course, you'll work on hands-on projects and coding exercises that reinforce your understanding of each design pattern. By the end, you'll have gained the confidence to apply these patterns in your Java projects, improving code modularity, reusability, and maintainability.

Whether you're a beginner seeking a solid foundation in design patterns or an experienced developer looking to enhance your software design skills, this course provides the expertise and practical experience necessary to excel in Java development. Enroll now and elevate your Java programming capabilities with design patterns.

Who this course is for:

For thos interested in programming

Software Design Patterns (Java)

What you'll learn

Explore related topics

Course content

SOLID Principles6 lectures • 22min

Creational Patterns3 lectures • 19min

Structural Design Patterns2 lectures • 8min

Behavioral Design Patterns2 lectures • 8min

Concurrency1 lecture • 2min

Requirements

Description

Who this course is for: