Fixing LSP violations — composition vs inheritance

Direct Answer

Fix an LSP violation by first identifying the broken base guarantee. You may correct the subtype, narrow or redesign the base contract, split capabilities into interfaces, or replace inheritance with composition. Removing inheritance is common, but it is not the only fix; the result must make every advertised subtype honor the contract.

Code Example

// Common interface with no shared mutable state
interface Shape {
    int getArea();
    int getPerimeter();
}

// Rectangle and Square are independent implementations
record Rectangle(int width, int height) implements Shape {
    @Override
    public int getArea() { return width * height; }
    
    @Override
    public int getPerimeter() { return 2 * (width + height); }
}

record Square(int side) implements Shape {
    @Override
    public int getArea() { return side * side; }
    
    @Override
    public int getPerimeter() { return 4 * side; }
}

// Now clients depend on Shape interface
void processShape(Shape shape) {
    var area = shape.getArea();  // Works for both, no surprises
    System.out.println("Area: " + area);
}

Common Mistakes & Pitfalls

• Throwing UnsupportedOperationException: Freshers think overriding a method to throw this exception is a valid fix — it's actually another LSP violation because callers still break at runtime.
• Abstract parent class with no-op methods: Creating an abstract base class where some methods do nothing, then making subclasses override them — this just moves the LSP violation around.
• Keeping inheritance and documenting restrictions: Adding JavaDoc that says "don't call setHeight on Square" is not a fix — code shouldn't rely on documentation to avoid crashes.
• Over-engineering with interfaces: Creating an interface with 20 methods when inheritance would work fine — LSP violations only matter when the subclass actually breaks substitution.