In what cases is inheritance in programming useful, and in which cases can it be inefficient?

Inheritance is useful for:

• Code reuse: Common methods and fields are defined in a base class and inherited by subclasses.
• Polymorphism: Subclass objects can be treated as objects of the base class, allowing a common interface for different implementations.
• Creating type hierarchies: Modeling "is-a" relationships between entities.

Inheritance can be inefficient or problematic in the following cases:

• Tight coupling: Changes in the base class can affect all its subclasses, complicating maintenance and refactoring.
• Diamond problem: In languages with multiple inheritance, when two classes inherit from a common base class, and a third class inherits from these two, ambiguity arises when calling methods. (not directly applicable in Java/Kotlin, but a conceptual problem of polymorphic hierarchy).
• Violation of LSP (Liskov Substitution Principle): A subclass cannot be used in place of a base class without altering the correctness of the program. Often indicates incorrect use of inheritance.
• Base class bloat: The base class becomes too complex and contains functions needed only by some subclasses.
• Fragility of the base class: Small changes in the base class can subtly break subclass behavior.

Alternative approaches such as composition ("has-a" relationships) and interfaces are often preferable to inheritance for achieving flexibility and loose coupling.