SOLID principles & Design Patterns for Java programmers

Trace the origin of the solid principles—open-closed principle, Liskov substitution principle, dependency inversion principle, interface segregation principle, and single responsibility principle—and how Uncle Bob and others shaped maintainable object-oriented design.

Apply the single responsibility principle, derived from cohesion, so each class has a single reason to change, avoiding mixing business logic with presentation logic.

Refactor the movie recommender to follow the single responsibility principle by separating recommendation logic from csv formatting, exclude seen movies, and implement a csv exporter to enforce title, director, genre.

Learn how the open-closed principle enables extending software by adding new shapes without modifying existing code, using a shape interface and painter delegation.

Explore the Liskov substitution principle (LSP), showing how inheritance and polymorphism require subtypes to preserve behaviors, illustrated with Java arrays, equals contracts, and date and timestamp cases.

Explore the interface segregation principle by splitting a communicator into separate interfaces: a communicator interface and an encryption interface, ensuring clients depend only on needed methods and promoting high cohesion.

Explore the dependency inversion principle by contrasting it with dependency injection, and learn to design high-level modules that depend on abstractions rather than low-level details across layered architectures.

Share feedback to help perfect this comprehensive course on solid principles and design patterns for java programmers. Engage with reviews, questions, and announcements via the Q&A tab and course updates.

Trace the origins of design patterns from architecture to software, recounting Alexander's pattern language and the GoF catalog of 23 patterns across creation, structure, and behavior.

Explore the chain of responsibility by modeling a coin-recognition system with individual recognizers that pass unhandled coins along a chain until one accepts, illustrating a behavioral design pattern.

Centralize the creation of related data repositories using the abstract factory pattern, enabling relational or NoSQL implementations for students and courses through interfaces without exposing concrete classes.

Master the builder pattern in Java to avoid telescoping constructors, using a person builder with mandatory name, optional birthplace, and adult or child variants via method chaining and build.

Apply the factory method pattern to encapsulate object creation for varying types, illustrated by car factories and a maze game with ordinary and magical rooms, without modifying common code.

Learn how the prototype pattern enables creating new, customized objects by copying a prototypical instance, illustrated with PDF table cells and a configuration that modifies only the fields that change.

Review the clone method on Java objects and its relation to the prototype pattern, cover CloneNotSupportedException, Cloneable, public visibility, property-by-property copying, deep copy, and practical drawbacks.

Explore the singleton pattern, its concurrency and serialization pitfalls, and safer implementations using a private constructor, synchronization, double-checked locking, a resolve method, and enums in Java.

Apply the adapter pattern by wrapping an existing reservation system with a new StandardReservationACME interface, translating calls without modifying the original code.

Learn how the bridge pattern separates abstraction from implementation to connect hierarchies. Apply this approach to build an adaptable online sales interface across shops using refined abstractions and concrete implementors.

Treats individual shapes and selections uniformly by composing objects into tree structures. Implements a shape interface for both leaves and composites, enabling uniform draw operations and flexible grouping.

Explore how the decorator pattern extends coffee functionality through composition by wrapping base coffees with extras, altering description and price without changing existing code.

The facade pattern provides a unified, higher-level interface to coordinate multiple subsystems, such as the secretary, curriculum, bookshop, and library, making matriculation process easier for Java programmers.

Explore the flyweight pattern, which shares intrinsic state to reduce memory, and distinguishes intrinsic, extrinsic, and context data, with Java string interning as a practical example.

Explore how the proxy pattern uses composition to add access control and delay creation via a virtual proxy, with Jpa as an example, delegating to the real object when authorized.

Explore how composition extends functionality by creating a new type that references the original, enabling proxy, decorator, adapter, and facade patterns with the same interface, embodying composition over inheritance.

Explore the chain of responsibility pattern, linking a chain of handlers to pass a request along until one handles it, reducing coupling and resolving diverse, independent cases.

Master the command pattern that encapsulates processing as an object to support multiple orders, including dangerous and international shipments.

Harness the interpreter pattern to define a grammar and parse a domain-specific language that evaluates grade calculations using add, product, variables, and literals against a student context.

Explore the iterator pattern and the visitor pattern, showing how to access elements sequentially and perform operations without exposing internal structure, illustrated by a ledger example.

Learn how the mediator pattern centralizes interactions among smart home devices such as lamp, alarm clock, TV, and radio to enforce rules with reduced coupling.

Explore the memento pattern to implement reliable undo functionality in a shopping basket, showing how to create deep copies of state to restore past states without breaking encapsulation.

Explore the observer pattern through a university enrollment example, turning enrollment events into published notifications to registered observers while decoupling the enrollment service from subsystems.

Explore how the state pattern lets an object change behavior based on its internal state, using a microwave oven example to illustrate state machines and transitions.

The strategy pattern encapsulates the tuition pricing algorithm, allowing runtime changes to how subject prices are calculated, supporting reference price, low-income discounts, and other variants.

The template method provides a super class skeleton and abstract steps to share the external structure of similar checks, as in masters and bachelor degree applications.

Explore unit testing of domain classes and how the builder pattern simplifies object creation, enabling readable tests for student, course, enrollment relations and prerequisites.

Explore the strangler pattern and facade approach to migrating legacy applications to the cloud through gradual, controlled steps, reducing risk while keeping a stable api for clients.

Reflect on applying solid principles and design patterns to real-world Java code, internalize the ideas to improve design decisions, and revisit the course to keep insights fresh.