Tell about your experience applying SOLID principles in practice.

The SOLID principles help create flexible, extendable, and maintainable code. In my practice, I applied them as follows:

• Single Responsibility Principle (SRP): I divided classes so that each was responsible for a single task. For example, in a project for order processing, I allocated separate classes for validation, cost calculation logic, and data storage.

• Open/Closed Principle (OCP): I used abstractions and interfaces to extend functionality without modifying existing code. For instance, I added new types of discounts through inheritance or interface implementation.

• Liskov Substitution Principle (LSP): I ensured that subclasses correctly replaced base classes without breaking logic. This helped avoid unexpected errors during polymorphic use.

• Interface Segregation Principle (ISP): I split large interfaces into smaller ones so that clients depended only on the methods they needed.

• Dependency Inversion Principle (DIP): I injected dependencies via constructors or setters using interfaces, which facilitated testing and component replacement.

An example in Java demonstrating SRP and DIP:

interface PaymentProcessor {
    void processPayment(double amount);
}

class CreditCardProcessor implements PaymentProcessor {
    public void processPayment(double amount) {
        // credit card payment logic
    }
}

class OrderService {
    private PaymentProcessor paymentProcessor;

    public OrderService(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public void placeOrder(double amount) {
        // other order logic
        paymentProcessor.processPayment(amount);
    }
}

This approach improves modularity and makes the code easier to maintain.