SOLID principles are fundamental to object-oriented design. Here’s how to apply them in Java.

S - Single Responsibility Principle

Bad

class User {
    public void save() { }
    public void sendEmail() { }
    public void generateReport() { }
}

Good

class User {
    // Only user data
}

class UserRepository {
    public void save(User user) { }
}

class EmailService {
    public void sendEmail(User user) { }
}

O - Open/Closed Principle

Bad

class AreaCalculator {
    public double calculateArea(Object shape) {
        if (shape instanceof Circle) {
            // Calculate circle area
        } else if (shape instanceof Rectangle) {
            // Calculate rectangle area
        }
    }
}

Good

interface Shape {
    double calculateArea();
}

class Circle implements Shape {
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    public double calculateArea() {
        return width * height;
    }
}

L - Liskov Substitution Principle

Bad

class Bird {
    public void fly() { }
}

class Penguin extends Bird {
    public void fly() {
        throw new UnsupportedOperationException();
    }
}

Good

interface Bird {
    void eat();
}

interface FlyingBird extends Bird {
    void fly();
}

class Sparrow implements FlyingBird {
    public void fly() { }
}

class Penguin implements Bird {
    // No fly method
}

I - Interface Segregation Principle

Bad

interface Worker {
    void work();
    void eat();
    void sleep();
}

class Robot implements Worker {
    public void eat() { } // Not applicable
    public void sleep() { } // Not applicable
}

Good

interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Human implements Workable, Eatable {
    public void work() { }
    public void eat() { }
}

class Robot implements Workable {
    public void work() { }
}

D - Dependency Inversion Principle

Bad

class UserService {
    private MySQLDatabase database;
    
    public UserService() {
        this.database = new MySQLDatabase();
    }
}

Good

interface Database {
    void save(User user);
}

class UserService {
    private Database database;
    
    public UserService(Database database) {
        this.database = database;
    }
}

Conclusion

SOLID principles help you write:

  • Maintainable code
  • Extensible systems
  • Testable components
  • Flexible architectures

Apply SOLID principles for better design! 🎯