Introduction to Design Patterns

1.1 What are Design Patterns?

• Definition:
  A Design Pattern is a proven reusable solution to a commonly occurring problem in software design.
• Instead of solving a problem from scratch, you apply a blueprint that has already been tested and documented.
• They are not code snippets but conceptual templates that can be implemented in different ways depending on the situation.

Example in real life:

• If you want to build a house, you don’t design it from zero every time — you follow architectural blueprints.
• Similarly, in Java programming, when you need to solve recurring problems like object creation, communication, or structure, you use design patterns.

1.2 History and Origin of Design Patterns (Gang of Four – GoF)

• The term Design Patterns was popularized by the book “Design Patterns: Elements of Reusable Object-Oriented Software” (1994) written by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides (collectively known as the Gang of Four or GoF).
• The GoF book classified 23 classic design patterns into Creational, Structural, and Behavioral categories.
• Since then, design patterns have become a standard vocabulary for software developers.

1.3 Why Use Design Patterns in Software Development?

• Consistency: Creates a standard way of solving problems.
• Reusability: Reduces duplicate efforts.
• Scalability: Helps scale applications without rewriting entire code.
• Maintainability: Easier to understand and modify code.
• Communication: Developers can talk in pattern names (e.g., "Use a Singleton here") instead of lengthy explanations.

1.4 Benefits of Using Design Patterns in Java

• Faster development time (reuse existing solutions).
• Reduced risk of errors (tested and proven patterns).
• Cleaner and more organized code.
• Improves collaboration among developers.
• Makes systems more flexible and extensible.

1.5 Difference Between Design Patterns, Architectures, and Algorithms

2. Principles Behind Design Patterns

Before we dive into actual design patterns, it’s important to understand the principles that guide their creation. These principles ensure that our software is flexible, reusable, and maintainable.

2.1 Object-Oriented Principles (OOP Recap)

Design patterns are built on OOP concepts:

1. Encapsulation → Hiding internal details and exposing only necessary functionality.
   • Example: private variables with public getters/setters.
2. Abstraction → Representing essential features without showing background details.
   • Example: List is an abstraction; whether it’s ArrayList or LinkedList doesn’t matter.
3. Inheritance → Reusing properties and behaviors from a parent class.
   • Example: class Dog extends Animal.
4. Polymorphism → Same interface, different implementations.
   • Example: shape.draw() could draw a circle, square, or triangle.

👉 Design patterns combine these OOP principles to solve recurring problems.

2.2 SOLID Principles in Java

SOLID is a set of five design principles that help build better software.

1. S – Single Responsibility Principle (SRP)
   • A class should have only one reason to change.
   • Example: A UserService should not handle both user login and database connection.
2. O – Open/Closed Principle (OCP)
   • Classes should be open for extension but closed for modification.
   • Example: Instead of modifying an existing class, use inheritance or interfaces to extend it.
3. L – Liskov Substitution Principle (LSP)
   • Subclasses should be replaceable by their parent class without breaking the program.
   • Example: If Bird has a method fly(), then Penguin extends Bird should not break functionality.
4. I – Interface Segregation Principle (ISP)
   • Don’t force a class to implement methods it doesn’t need.
   • Example: Instead of one large interface Vehicle with fly(), drive(), and sail(), break it into smaller interfaces.
5. D – Dependency Inversion Principle (DIP)
   • Depend on abstractions, not concrete implementations.
   • Example: Use List instead of ArrayList in variable declarations.

2.3 Other Principles Behind Patterns

• DRY (Don’t Repeat Yourself): Avoid duplicate code; abstract common logic into reusable components.
• KISS (Keep It Simple, Stupid): Simplicity makes code easier to understand and maintain.
• YAGNI (You Aren’t Gonna Need It): Don’t implement functionality until it’s actually needed.
• Composition over Inheritance: Prefer composing objects (has-a relationship) instead of deep inheritance (is-a relationship).
• Program to Interfaces, not Implementations: Write code using interfaces to keep flexibility.
  
  Click here to Know more in detail

2.4 Dependency Injection & Inversion of Control

Here’s a detailed explanation of Dependency Injection (DI) and Inversion of Control (IoC):

A. Inversion of Control (IoC)

Inversion of Control (IoC) is a design principle in software engineering that reverses the traditional flow of control in a program.

• In a traditional program, the application code is responsible for creating objects, managing their lifecycles, and calling methods when needed.
• With IoC, this control is handed over (inverted) to an external framework or container (like Spring in Java).

In simple terms, instead of the programmer writing code to create and manage dependencies, the framework does it. The programmer only specifies what is required, and the framework provides it.

Example Without IoC (Traditional Way):

class Service {
    public void serve() {
        System.out.println("Service is working");
    }
}

class Client {
    private Service service;

    public Client() {
        // Programmer is directly controlling object creation
        this.service = new Service();
    }

    public void doWork() {
        service.serve();
    }
}

Here, Client is tightly coupled with Service because it creates the object itself.

Example With IoC (Framework Control):

class Service {
    public void serve() {
        System.out.println("Service is working");
    }
}

class Client {
    private Service service;

    // Service object will be passed from outside, not created here
    public Client(Service service) {
        this.service = service;
    }

    public void doWork() {
        service.serve();
    }
}

Now, the framework (e.g., Spring IoC Container) decides how to create and inject the Service object into Client. The programmer is not responsible for object creation, only for declaring dependencies.

B. Dependency Injection (DI)

Dependency Injection (DI) is a specific technique to achieve IoC. Instead of a class creating its dependencies internally, the dependencies are provided (injected) to the class from an external source.

This makes the system more modular, testable, and loosely coupled.

There are three common types of dependency injection:

1. Constructor Injection – Dependencies are provided through a class constructor.

   class Client {
       private Service service;
   
       public Client(Service service) {   // Dependency injected here
           this.service = service;
       }
   }
   

2. Setter Injection – Dependencies are provided via setter methods.

   class Client {
       private Service service;
   
       public void setService(Service service) {   // Dependency injected here
           this.service = service;
       }
   }
   

3. Field Injection – Dependencies are injected directly into fields (often using annotations like @Autowired in Spring).

   class Client {
       @Autowired
       private Service service;
   }
   

C. Difference Between IoC and DI

D. Advantages of DI & IoC

• Loose Coupling: Classes are less dependent on each other, making the system more flexible.
• Better Testability: Dependencies can be replaced with mock objects easily during unit testing.
• Code Reusability: Classes can be reused in different contexts because they do not create their own dependencies.
• Easier Maintenance: Since object creation and wiring are handled by the framework, code is cleaner and easier to manage.
• Scalability: Large applications with many dependencies can be managed effectively through containers.

 These principles are the foundation of many design patterns, especially Singleton, Factory, and Dependency Injection patterns.

3. Classification of Design Patterns

The Gang of Four (GoF) grouped 23 design patterns into three major categories based on their purpose:

3.1 Creational Design Patterns

• Focus: Object creation mechanisms.
• Why: In large applications, creating objects directly with new can lead to tight coupling and difficulty in scaling.
• Solution: Creational patterns provide flexible ways of instantiating and managing objects.

Patterns Included:

A. Singleton Pattern

Definition:
The Singleton pattern ensures that a class has only one instance and provides a global point of access to it.

When to Use:

• Logging
• Database connections
• Configuration settings
• Caches

Real-World Example:

• There should be only one President of a country at a time.
• Similarly, in software, we ensure only one instance of a class exists.

Java Example:

// Eager Initialization Singleton
public class Singleton {
    // Create only one instance (eagerly loaded)
    private static final Singleton instance = new Singleton();

    // Private constructor prevents instantiation
    private Singleton() {}

    // Global point of access
    public static Singleton getInstance() {
        return instance;
    }

    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Singleton obj = Singleton.getInstance();
        obj.showMessage();
    }
}

Advantages:

• Saves memory by avoiding multiple instances.
• Useful for shared resources.

Disadvantages:

• Can be hard to unit test (tight coupling).
• Overused in many projects → anti-pattern if misapplied.

B. Factory Method Pattern

Definition:
The Factory Method pattern provides an interface for creating objects, but lets subclasses decide which class to instantiate.

When to Use:

• When you don’t know the exact type of object needed at runtime.
• When object creation logic is complex.

Real-World Example:

• A Car Factory can produce Sedan, SUV, or Hatchback depending on input.

Java Example:

// Product Interface
interface Car {
    void drive();
}

// Concrete Products
class Sedan implements Car {
    public void drive() {
        System.out.println("Driving a Sedan...");
    }
}

class SUV implements Car {
    public void drive() {
        System.out.println("Driving an SUV...");
    }
}

// Factory Class
class CarFactory {
    public static Car getCar(String type) {
        if (type.equalsIgnoreCase("Sedan")) return new Sedan();
        else if (type.equalsIgnoreCase("SUV")) return new SUV();
        return null;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Car car1 = CarFactory.getCar("Sedan");
        car1.drive();

        Car car2 = CarFactory.getCar("SUV");
        car2.drive();
    }
}

Advantages:

• Decouples client code from object creation.
• Easy to add new product types.

Disadvantages:

• Can introduce many subclasses.

c. Abstract Factory Pattern

Definition:
The Abstract Factory pattern provides an interface for creating families of related objects, without specifying their concrete classes.

When to Use:

• When you want to create related objects (GUI elements, cars, etc.) that should work together.
• Useful when system should be independent of how its objects are created.

Real-World Example:

• A Furniture Factory can create a Modern Chair and Modern Sofa, or a Victorian Chair and Victorian Sofa.
• Both belong to the same family (Modern or Victorian).

Java Example:

// Abstract Products
interface Chair { void sitOn(); }
interface Sofa { void lieOn(); }

// Concrete Products - Modern
class ModernChair implements Chair {
    public void sitOn() { System.out.println("Sitting on a modern chair."); }
}
class ModernSofa implements Sofa {
    public void lieOn() { System.out.println("Lying on a modern sofa."); }
}

// Concrete Products - Victorian
class VictorianChair implements Chair {
    public void sitOn() { System.out.println("Sitting on a victorian chair."); }
}
class VictorianSofa implements Sofa {
    public void lieOn() { System.out.println("Lying on a victorian sofa."); }
}

// Abstract Factory
interface FurnitureFactory {
    Chair createChair();
    Sofa createSofa();
}

// Concrete Factories
class ModernFurnitureFactory implements FurnitureFactory {
    public Chair createChair() { return new ModernChair(); }
    public Sofa createSofa() { return new ModernSofa(); }
}

class VictorianFurnitureFactory implements FurnitureFactory {
    public Chair createChair() { return new VictorianChair(); }
    public Sofa createSofa() { return new VictorianSofa(); }
}

// Usage
public class Main {
    public static void main(String[] args) {
        FurnitureFactory factory = new ModernFurnitureFactory();
        Chair chair = factory.createChair();
        Sofa sofa = factory.createSofa();

        chair.sitOn();
        sofa.lieOn();
    }
}

Advantages:

• Ensures products from the same family are used together.
• Adds consistency across related products.

Disadvantages:

• Can be complex when too many families exist.

D. Builder Pattern

Definition:
The Builder pattern allows creating a complex object step by step, without requiring a complex constructor.

When to Use:

• When an object has many optional parameters.
• When object creation is complicated.

Real-World Example:

• Building a Burger → You choose bun, patty, cheese, toppings step by step.

Java Example:

class Burger {
    private String bun;
    private String patty;
    private String cheese;
    private String toppings;

    // Private constructor
    private Burger(BurgerBuilder builder) {
        this.bun = builder.bun;
        this.patty = builder.patty;
        this.cheese = builder.cheese;
        this.toppings = builder.toppings;
    }

    static class BurgerBuilder {
        private String bun;
        private String patty;
        private String cheese;
        private String toppings;

        public BurgerBuilder bun(String bun) { this.bun = bun; return this; }
        public BurgerBuilder patty(String patty) { this.patty = patty; return this; }
        public BurgerBuilder cheese(String cheese) { this.cheese = cheese; return this; }
        public BurgerBuilder toppings(String toppings) { this.toppings = toppings; return this; }

        public Burger build() { return new Burger(this); }
    }

    public void showBurger() {
        System.out.println("Burger with " + bun + ", " + patty + ", " + cheese + ", " + toppings);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Burger burger = new Burger.BurgerBuilder()
                .bun("Sesame Bun")
                .patty("Beef Patty")
                .cheese("Cheddar")
                .toppings("Lettuce, Tomato")
                .build();

        burger.showBurger();
    }
}

Advantages:

• Handles complex objects easily.
• Improves readability (fluent interface).

Disadvantages:

• Requires additional classes (Builder).

E. Prototype Pattern

Definition:
The Prototype pattern allows you to clone existing objects instead of creating new ones.

When to Use:

• When object creation is costly (e.g., database, file system).
• When you want to duplicate objects with slight modifications.

Real-World Example:

• Copying a document template instead of creating from scratch.

Java Example:

// Prototype interface
interface Prototype extends Cloneable {
    Prototype clone();
}

// Concrete class
class Document implements Prototype {
    private String content;

    public Document(String content) { this.content = content; }

    public void show() { System.out.println("Document Content: " + content); }

    @Override
    public Prototype clone() {
        return new Document(this.content);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Document original = new Document("Hello, World!");
        Document copy = (Document) original.clone();

        original.show();
        copy.show();
    }
}

Advantages:

• Reduces expensive object creation.
• Easy to duplicate objects.

Disadvantages:

• Cloning complex objects can be tricky.

3.2 Structural Design Patterns

• Focus: How classes and objects are structured to form larger systems.
• Why: To simplify relationships and create reusable object compositions.
• Solution: These patterns define composition and object relationships rather than inheritance.

Patterns Included:

A. Adapter Pattern

Definition:
The Adapter pattern allows incompatible interfaces to work together by acting as a bridge between them.

When to Use:

• When you want to use an existing class but its interface does not match your needs.
• When integrating with third-party libraries.

Real-World Example:

• A mobile charger is an adapter that allows your phone (micro-USB/USB-C) to connect to a wall socket (AC).

Java Example:

// Target interface
interface MediaPlayer {
    void play(String audioType, String fileName);
}

// Adaptee class (incompatible interface)
class AdvancedMediaPlayer {
    void playMp4(String fileName) {
        System.out.println("Playing MP4 file: " + fileName);
    }
}

// Adapter class
class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedPlayer = new AdvancedMediaPlayer();

    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp4")) {
            advancedPlayer.playMp4(fileName);
        } else {
            System.out.println("Format not supported: " + audioType);
        }
    }
}

// Client
class AudioPlayer implements MediaPlayer {
    MediaAdapter adapter;

    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing MP3 file: " + fileName);
        } else {
            adapter = new MediaAdapter();
            adapter.play(audioType, fileName);
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        AudioPlayer player = new AudioPlayer();
        player.play("mp3", "song1.mp3");
        player.play("mp4", "video.mp4");
    }
}

Advantages:

• Makes incompatible interfaces compatible.
• Promotes code reusability.

Disadvantages:

• Can add extra layers of complexity.

B. Bridge Pattern

Definition:
The Bridge pattern decouples abstraction from implementation, so both can vary independently.

When to Use:

• When you want to separate an abstraction (e.g., Shape) from its implementation (e.g., Color).
• When both abstraction and implementation may change in the future.

Real-World Example:

• TV Remote → Remote (abstraction) works with different brands of TVs (implementation).

Java Example:

// Implementor
interface Color {
    void applyColor();
}

// Concrete Implementors
class Red implements Color {
    public void applyColor() { System.out.println("Applying Red color."); }
}
class Blue implements Color {
    public void applyColor() { System.out.println("Applying Blue color."); }
}

// Abstraction
abstract class Shape {
    protected Color color;

    public Shape(Color color) {
        this.color = color;
    }

    abstract void draw();
}

// Refined Abstraction
class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }
    void draw() {
        System.out.print("Circle filled with ");
        color.applyColor();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new Red());
        Shape blueCircle = new Circle(new Blue());

        redCircle.draw();
        blueCircle.draw();
    }
}

Advantages:

• Decouples abstraction from implementation.
• Increases flexibility and scalability.

Disadvantages:

• Adds complexity by requiring multiple layers.

C. Composite Pattern

Definition:
The Composite pattern lets you treat individual objects and groups of objects uniformly.

When to Use:

• When you want to represent part-whole hierarchies (tree structures).
• When clients should not care if they’re dealing with a single object or a group.

Real-World Example:

• A Folder contains files and other folders. Both are treated the same way when browsing.

Java Example:

import java.util.ArrayList;
import java.util.List;

// Component
interface FileSystem {
    void showDetails();
}

// Leaf
class File implements FileSystem {
    private String name;
    public File(String name) { this.name = name; }
    public void showDetails() { System.out.println("File: " + name); }
}

// Composite
class Folder implements FileSystem {
    private String name;
    private List items = new ArrayList<>();

    public Folder(String name) { this.name = name; }

    public void add(FileSystem item) { items.add(item); }

    public void showDetails() {
        System.out.println("Folder: " + name);
        for (FileSystem item : items) {
            item.showDetails();
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        File file1 = new File("Resume.docx");
        File file2 = new File("Photo.png");

        Folder folder = new Folder("My Documents");
        folder.add(file1);
        folder.add(file2);

        folder.showDetails();
    }
}

Advantages:

• Simplifies client code.
• Handles hierarchical structures neatly.

Disadvantages:

• Can make system design too general, harder to enforce rules.

D. Decorator Pattern

Definition:
The Decorator pattern lets you add new behavior to objects dynamically, without altering their structure.

When to Use:

• When you want to extend functionality without modifying original classes.
• Alternative to subclassing.

Real-World Example:

• Adding extra toppings on a pizza without changing the base pizza class.

Java Example:

// Component
interface Coffee {
    String getDescription();
    double getCost();
}

// Concrete Component
class SimpleCoffee implements Coffee {
    public String getDescription() { return "Simple Coffee"; }
    public double getCost() { return 5.0; }
}

// Decorator
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    public CoffeeDecorator(Coffee coffee) { this.coffee = coffee; }
}

// Concrete Decorators
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) { super(coffee); }
    public String getDescription() { return coffee.getDescription() + ", Milk"; }
    public double getCost() { return coffee.getCost() + 1.5; }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) { super(coffee); }
    public String getDescription() { return coffee.getDescription() + ", Sugar"; }
    public double getCost() { return coffee.getCost() + 0.5; }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        coffee = new MilkDecorator(coffee);
        coffee = new SugarDecorator(coffee);

        System.out.println(coffee.getDescription() + " → $" + coffee.getCost());
    }
}

Advantages:

• Flexible way to add new features.
• Promotes composition over inheritance.

Disadvantages:

• Can lead to too many small classes.

E. Facade Pattern

Definition:
The Facade pattern provides a simplified interface to a complex subsystem.

When to Use:

• When you want to hide complexity from clients.
• To reduce dependencies between client and subsystem.

Real-World Example:

• A restaurant waiter acts as a facade → You don’t talk to the chef, manager, and cashier separately.

Java Example:

// Subsystems
class CPU {
    void start() { System.out.println("CPU started."); }
}
class Memory {
    void load() { System.out.println("Memory loaded."); }
}
class HardDrive {
    void read() { System.out.println("Hard drive reading data."); }
}

// Facade
class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private HardDrive hd;

    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.hd = new HardDrive();
    }

    public void startComputer() {
        cpu.start();
        memory.load();
        hd.read();
        System.out.println("Computer is ready to use!");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.startComputer();
    }
}

Advantages:

• Reduces complexity for client.
• Shields clients from subsystem changes.

Disadvantages:

• May become a “god object” if not designed carefully.

F. Flyweight Pattern

Definition:
The Flyweight pattern is used to minimize memory usage by sharing objects that are similar.

When to Use:

• When you have a huge number of objects that share common state.
• Example: Characters in a text editor, trees in a game.

Real-World Example:

• Chess game → All white pawns share the same representation, only position differs.

Java Example:

import java.util.HashMap;
import java.util.Map;

// Flyweight
interface Shape {
    void draw(int x, int y);
}

// Concrete Flyweight
class Circle implements Shape {
    private String color;  // Intrinsic state

    public Circle(String color) { this.color = color; }

    public void draw(int x, int y) {
        System.out.println("Drawing " + color + " circle at (" + x + ", " + y + ")");
    }
}

// Flyweight Factory
class ShapeFactory {
    private static final Map circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Circle circle = (Circle) circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Created new circle of color: " + color);
        }
        return circle;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape redCircle1 = ShapeFactory.getCircle("Red");
        redCircle1.draw(10, 20);

        Shape redCircle2 = ShapeFactory.getCircle("Red");
        redCircle2.draw(30, 40);
    }
}

Advantages:

• Saves memory.
• Efficient when dealing with many similar objects.

Disadvantages:

• Hard to implement when objects have too much unique state.

G. Proxy Pattern

Definition:
The Proxy pattern provides a substitute or placeholder for another object to control access to it.

Types of Proxies:

• Virtual Proxy → Delay object creation until needed.
• Protection Proxy → Control access based on permissions.
• Remote Proxy → Represent object in a different address space.

Real-World Example:

• ATM card acts as a proxy to your bank account.

Java Example:

// Subject
interface Image {
    void display();
}

// Real Subject
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading " + fileName);
    }

    public void display() {
        System.out.println("Displaying " + fileName);
    }
}

// Proxy
class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName); // Lazy loading
        }
        realImage.display();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Image image = new ProxyImage("photo.jpg");

        image.display(); // Loads and displays
        image.display(); // Displays without loading again
    }
}

Advantages:

• Adds security, lazy loading, or caching.
• Controls access to real objects.

Disadvantages:

• Adds an extra layer and complexity.

Key Takeaways

Design patterns are proven, reusable solutions to recurring software design problems. They are not ready-made code but conceptual blueprints that guide flexible, maintainable, and scalable solutions. Patterns are built on strong OOP and SOLID principles, supported by concepts like Dependency Injection (DI) and Inversion of Control (IoC), which promote loose coupling and reusability. The Creational Patterns help manage object creation (Singleton, Factory, Abstract Factory, Builder, Prototype), while the Structural Patterns simplify class/object composition and relationships (Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy). Each pattern comes with its advantages, trade-offs, and real-world analogies, making them easier to understand and apply in Java development.

This lays a strong foundation to move forward into the Behavioral Design Patterns, which focus on communication and responsibilities between objects.

👉 To be continued…

Next Blog- Design Patterns in Java