liskov-substitution-principle

The Liskov Substitution Principle ensures subclasses can replace parent types without altering program behavior. It requires overrides to preserve contracts and invariants, preventing broken substitutability across component hierarchies.

To stop subclasses from throwing exceptions in method overrides, enforce override discipline by flagging throwing or no-op implementations. This ensures subclasses uphold parent contracts and maintains correct substitutability.

Use composition over inheritance when subclassing risks breaking parent contracts. Separating capabilities via interfaces and using composition prevents LSP violations that arise from forcing incompatible behaviors into a rigid hierarchy.

Validate subclass contracts during refactoring by reviewing the class hierarchy to ensure all overrides preserve invariants. This checks for no-op implementations and throwing overrides to guarantee correct behavior across components.

Your subclass override breaks expected behavior because it violates the parent's contract. No-op implementations or throwing new exceptions disrupt substitutability, meaning the subclass can no longer replace the parent type cleanly.

Yes, you can separate capabilities via interfaces to maintain substitutability. This design practice prevents LSP violations by allowing components to adopt specific behaviors without forcing incompatible method overrides in a class hierarchy.