SOLID Principles in Java: A Comprehensive Guide

SOLID is an acronym for five design principles that help software developers design maintainable and scalable software. These principles, introduced by Robert C. Martin, are fundamental to object-oriented programming and design. This article explores each of the SOLID principles and how to implement them in Java.

1. Single Responsibility Principle (SRP)

The Single Responsibility Principle states that a class should have only one reason to change, meaning it should have only one job or responsibility.

Example

// Before SRP
public class UserService {
    public void createUser(User user) {
        // Code to create a user
    }

    public void sendEmail(User user) {
        // Code to send an email
    }

    public void saveToDatabase(User user) {
        // Code to save user to database
    }
}

// After SRP
public class UserService {
    public void createUser(User user) {
        // Code to create a user
    }
}

public class EmailService {
    public void sendEmail(User user) {
        // Code to send an email
    }
}

public class UserRepository {
    public void save(User user) {
        // Code to save user to database
    }
}

2. Open/Closed Principle (OCP)

The Open/Closed Principle states that software entities should be open for extension but closed for modification. This means you should be able to add new functionality without changing existing code.

Example

// Before OCP
public class PaymentService {
    public void processPayment(String paymentType) {
        if (paymentType.equals("credit")) {
            // Process credit payment
        } else if (paymentType.equals("paypal")) {
            // Process PayPal payment
        }
    }
}

// After OCP
public interface PaymentProcessor {
    void process();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process() {
        // Process credit card payment
    }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void process() {
        // Process PayPal payment
    }
}

public class PaymentService {
    public void processPayment(PaymentProcessor processor) {
        processor.process();
    }
}

3. Liskov Substitution Principle (LSP)

The Liskov Substitution Principle states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

Example

// Before LSP
public class Bird {
    public void fly() {
        // Code to fly
    }
}

public class Ostrich extends Bird {
    @Override
    public void fly() {
        // Ostrich can't fly
        throw new UnsupportedOperationException("Ostrich can't fly");
    }
}

// After LSP
public abstract class Bird {
    public abstract void move();
}

public class Sparrow extends Bird {
    @Override
    public void move() {
        // Code to fly
    }
}

public class Ostrich extends Bird {
    @Override
    public void move() {
        // Code to run
    }
}

4. Interface Segregation Principle (ISP)

The Interface Segregation Principle states that no client should be forced to depend on methods it does not use. Instead of one large interface, many small interfaces are preferred based on specific needs.

Example

// Before ISP
public interface Worker {
    void work();
    void eat();
}

public class HumanWorker implements Worker {
    @Override
    public void work() {
        // Code to work
    }

    @Override
    public void eat() {
        // Code to eat
    }
}

public class RobotWorker implements Worker {
    @Override
    public void work() {
        // Code to work
    }

    @Override
    public void eat() {
        // Robots don't eat
        throw new UnsupportedOperationException("Robots don't eat");
    }
}

// After ISP
public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public class HumanWorker implements Workable, Eatable {
    @Override
    public void work() {
        // Code to work
    }

    @Override
    public void eat() {
        // Code to eat
    }
}

public class RobotWorker implements Workable {
    @Override
    public void work() {
        // Code to work
    }
}

5. Dependency Inversion Principle (DIP)

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. Additionally, abstractions should not depend on details. Details should depend on abstractions.

Example

// Before DIP
public class LightBulb {
    public void turnOn() {
        // Turn on the light bulb
    }

    public void turnOff() {
        // Turn off the light bulb
    }
}

public class Switch {
    private LightBulb lightBulb;

    public Switch(LightBulb lightBulb) {
        this.lightBulb = lightBulb;
    }

    public void operate() {
        if (lightBulb.isOn()) {
            lightBulb.turnOff();
        } else {
            lightBulb.turnOn();
        }
    }
}

// After DIP
public interface Switchable {
    void turnOn();
    void turnOff();
    boolean isOn();
}

public class LightBulb implements Switchable {
    private boolean on;

    @Override
    public void turnOn() {
        on = true;
    }

    @Override
    public void turnOff() {
        on = false;
    }

    @Override
    public boolean isOn() {
        return on;
    }
}

public class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        if (device.isOn()) {
            device.turnOff();
        } else {
            device.turnOn();
        }
    }
}

Conclusion

Implementing SOLID principles in Java helps create software that is maintainable, scalable, and robust. These principles encourage better design practices, making the code easier to understand, modify, and extend. By following the SOLID principles, developers can create high-quality software that meets the demands of modern applications.