Problems 😔

Wrong abstraction
Subclassification for code reuse
Misleading hierarchy
Unused or overridden methods
Unnecessary complexity
Liskov Principle Violation
Maintenanabiilty
YoYo Hierachies
Concrete classes subclassified

Solutions 😃

Favor composition over inheritance
Don't subclassify for code reuse
Rethink hierarchy
Extract shared logic
Use interfaces
Remove dead code

Refactorings ⚙️

Refactoring 007 - Extract Class

Context 💬

When you create a subclass, it should use or extend the behavior of its parent.

If it ignores or overrides most of it, you probably force inheritance where it doesn’t belong to reuse code.

This makes the code misleading and hard to maintain.

Sample Code 📖

Wrong 🚫

class House {
  constructor(address) {
    this.address = address;
  }
  address() {
    return this.address;
  }
  openDoor() {
    console.log("Door opened at " + this.address);
  }
}

class Motorhome extends House {
  constructor() {
    super(null);
  }
  address() {
    return null;
    // This implementation is the same as the parent's
    // and is also a refused bequest
  }
  openDoor() {
    console.log("Motorhome door opened.");
  }
}

Right 👉

class House {
  constructor(address) {
    this.address = address;
  }
  address() {
    return this.address;
  }
  openDoor() {
    console.log("Door opened at " + this.address);
  }
}

class Motorhome {
  // does not inherit from House
  constructor(gps) {
    this.gps = gps;
  }
  openDoor() {
    console.log("Motorhome door opened at " + this.gps.getLocation());
  }
}

Detection 🔍

[x]Manual

Look for subclasses that override or ignore most of their parent’s behavior.

You should reconsider the inheritance if a subclass sets parent properties to null or reimplements core methods.

Tags 🏷️

Inheritance

Level 🔋

[x]Intermediate

Why the Bijection Is Important 🗺️

Your software should reflect real-world relationships.

When you force a subclass that doesn’t logically extend its parent in the Bijection, you mislead developers and introduce maintenance problems.

AI Generation 🤖

AI can generate this smell when it defaults to inheritance for reuse instead of composition.

This happens when AI follows generic templates without understanding the context.

AI Detection 🥃

AI can detect this smell by analyzing class structures and inheritance trees. However, it struggles with subtle cases where inheritance initially seems valid but breaks expectations.