Tell about the principles of SOLID. Which do you know and how do you apply them in practice?

SOLID is a set of five principles of object-oriented design that help create flexible, extendable, and maintainable code:

• S (Single Responsibility Principle) — the principle of single responsibility. Each class should have one reason to change, meaning it should be responsible for one task.
• O (Open/Closed Principle) — openness/closedness. Classes should be open for extension but closed for modification.
• L (Liskov Substitution Principle) — Barbara Liskov's substitution principle. Subclass objects should be interchangeable with superclass objects without breaking the logic.
• I (Interface Segregation Principle) — the principle of interface segregation. It's better to have several specialized interfaces than one universal interface.
• D (Dependency Inversion Principle) — the principle of dependency inversion. High-level modules should not depend on low-level modules; both should depend on abstractions.

In practice, I apply these principles as follows:

• Break large classes into smaller ones with clear responsibilities.
• Use abstractions and interfaces to extend functionality without changing existing code.
• Follow interface contracts so subclasses correctly replace base classes.
• Create narrowly specialized interfaces for clients.
• Inject dependencies through constructors or factories to reduce coupling.

Example of applying SRP:

// Bad: class responsible for both logic and output
class Report {
    void generate() { /* report generation */ }
    void print() { /* report output */ }
}

// Good: separation of responsibilities
class ReportGenerator {
    void generate() { /* report generation */ }
}
class ReportPrinter {
    void print() { /* report output */ }
}