SOLID is an acronym representing five fundamental design principles for object-oriented programming that promote clean, maintainable, and extensible code:

• S - Single Responsibility Principle: A class should have only one reason to change
• O - Open/Closed Principle: Software entities should be open for extension but closed for modification
• L - Liskov Substitution Principle: Objects should be replaceable with instances of their subtypes
• I - Interface Segregation Principle: Clients should not depend on interfaces they don't use
• D - Dependency Inversion Principle: Depend on abstractions, not concretions

Benefits of following SOLID principles:

• Maintainability: Changes are localized and predictable
• Flexibility: Easy to extend and modify existing functionality
• Testability: Components can be tested in isolation
• Reusability: Well-designed components can be reused across different contexts
• Reduced coupling: Components are loosely connected and independently changeable
• Code clarity: Intent and structure are clearer and easier to understand

The Single Responsibility Principle states that a class should have only one reason to change, meaning it should have only one responsibility or job. A class should focus on a single aspect of the software's functionality.

Example of violation:

class User {
    private String name;
    private String email;
    
    // User data management
    public void setName(String name) { this.name = name; }
    
    // Email functionality - violates SRP
    public void sendEmail(String message) {
        // email sending logic
    }
    
    // Database operations - violates SRP
    public void saveToDatabase() {
        // database saving logic
    }
}

Better approach:

class User {
    private String name;
    private String email;
    // Only user data management
}

class EmailService {
    public void sendEmail(User user, String message) { }
}

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

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

Example:

// Violates OCP - need to modify for new shapes
class AreaCalculator {
    public double calculateArea(Object shape) {
        if (shape instanceof Rectangle) {
            Rectangle r = (Rectangle) shape;
            return r.width * r.height;
        } else if (shape instanceof Circle) {
            Circle c = (Circle) shape;
            return Math.PI * c.radius * c.radius;
        }
        return 0;
    }
}

// Follows OCP - extensible without modification
interface Shape {
    double calculateArea();
}

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

class AreaCalculator {
    public double calculateArea(Shape shape) {
        return shape.calculateArea();
    }
}