Software Architectures (SOLID) & Design Patterns in Java

Explore the SOLID principles—single responsibility principle, open-closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle—and their role in sustainable, maintainable, scalable object-oriented software design.

Learn the single responsibility principle: keep each class or endpoint focused on a single task. Separate database operations from reporting using interfaces and abstraction to achieve loose coupling.

Explore the single responsibility principle in a Java example that splits input processing, validation, and a violation checker, with a separate operation into dedicated components.

Provide a solution to a programming exercise that collects five integers from the user within the range zero and ten. Validate input, sort with collections.sort, and print the results.

Discover how the open/closed principle minimizes changes by extending behavior without modifying code, and see how abstraction, single responsibility, and patterns like strategy and decorator support it.

Explore the open-closed principle with a concrete java example, showing how interfaces and a processor enable loose coupling and extendable design without modifying existing code.

Implement and compare sorting algorithms—insertion sort, selection sort, and merge sort—using a sorting algorithm interface and a sorting processor to demonstrate abstraction and the open-closed principle.

Apply the Liskov substitution principle to ensure that subclasses replace superclasses without breaking functionality, enabling interchangeable, extensible, and scalable software architectures.

Explore a concrete Liskov substitution principle example using a vehicle hierarchy, showing petrol and electric cars, abstract classes and interfaces to ensure substitutability and prevent design smells.

Learn the motivation for the interface segregation principle, avoid fat interfaces, and split large interfaces into smaller ones so no client depends on unused methods; Java supports multiple interface implementations.

Examine the interface segregation principle through a concrete binary search tree example, contrasting fat interfaces with specialized interfaces and illustrating left and right rotations in balance trees.

Demonstrate the interface segregation principle by creating focused interfaces for employees, managers, and CEOs, enabling salary, hiring, training, decisions, stocks, and year-end bonuses while avoiding fat interfaces.

Explore the dependency inversion principle, showing how abstractions and interfaces decouple high and low level modules by programming to interfaces rather than details.

Explore inversion of control and dependency inversion in practice, using interfaces and constructor injection to decouple components, and see how frameworks like Spring orchestrate calls via the Hollywood principle.

Explore the dependency inversion principle by decoupling a web store from concrete payment methods through a payment method interface; switch PayPal, Skrill, or Payoneer at runtime via the payment controller.

Explore how design principles like SOLID serve as high-level guidelines, while design patterns provide concrete, tested solutions for creational, structural, and behavioral challenges in software.

Explore the singleton pattern in Java, covering eager and lazy initialization, private constructors, and getInstance. Assess synchronization drawbacks and why enums provide a thread-safe alternative in multi-threaded contexts.

Explore using an enum as the singleton database to guarantee thread safety, resist reflection attacks, and avoid slow synchronization while ensuring a single instance.