TL;DR: Always Favor composition over inheritance.

Problems

• Coupling

• Maintainability

Solutions

• Composition

Exceptions

• If the hierarchy follows the principle behaves like then it is safe.

Sample Code

Wrong

open class Rectangle(
    protected val length: Int,
    protected val width: Int
) {
    open fun area() = length * width
}

class Square(size: Int) : Rectangle(size, size) {
    override fun area() = length * length
}

class Box(size: Int) : Rectangle(size, size)

Right

interface Shape {
    fun area(): Int
}

class Rectangle(
    private val length: Int,
    private val width: Int
) : Shape {
    override fun area() = length * width
}

class Square(private val size: Int) : Shape {
    override fun area() = size * size
}

class Box(size: Int) {
    private val shape: Square

    init {
        shape = Square(size)
    }

    fun area() = shape.area()
}

Conclusion

In legacy systems is very common to have Deep Hierarchies and method overriding, we need to refactor them and subclass them by essential reasons and not implementation ones.

More info

• Liskov Substitution

• Inheritance (IS-A) vs. Composition (HAS-A) Relationship

Credits

• Code Smell 11 - Subclassification for Code Reuse by Maxi Contieri