07-08-problems-with-class-inheritance

Problems with Class Inheritance in TypeScript:

Fragile Base Class Problem:
When you have a class that other classes extend from (a base class), making changes to it can cause unexpected problems in the classes that extend from it. This is because the extending classes might depend on how the base class works internally.
- Code Example:
```
class Base {
  init() {
    this.setup();
  }

  setup() {
    // base setup
  }
}

class Derived extends Base {
  setup() {
    // additional setup
  }
}

// Changing 'setup' in 'Base' can break 'Derived' if 'Derived' depends on 'Base's setup.
```
Inheritance Hierarchy Complexity:
If you use inheritance to make many layers of classes (like a class that extends from another class, which extends from another, and so on), it can be hard to keep track of everything and make changes later.
- Code Example:
```
class Animal {}
class Mammal extends Animal {}
class Cat extends Mammal {}

// The deeper this goes, the harder it is to understand and maintain.
```

Method Overriding Issues:

When a class overrides a method from its base class, it can cause problems if it doesn't correctly use the base class's method (with super) or if it changes the way the method is supposed to work.

Code Example:

class Component {
  render() {
    console.log("Component on render");
  }
}

class Button extends Component {
  render() {
    // Overriding without calling super.render() may lead to unexpected behavior.
    console.log("Button on render");
  }
}

Tight Coupling:

Inheritance makes classes closely connected (tightly coupled), which can make the code less flexible and harder to change parts without affecting others.

Code Example:

class Engine {
  start() {
    // start engine
  }
}

class Car extends Engine {
  start() {
    // starting a car engine
    super.start();
  }
}

// 'Car' is tightly coupled to 'Engine'. Changes in 'Engine' may impact 'Car'.

The Diamond Problem:
TypeScript avoids problems like the "diamond problem" by not allowing classes to inherit from more than one class. This problem happens when a class inherits from two classes that both inherit from the same base class, which can cause confusion about which version of the base class's methods and properties to use.
- Conceptual Example:
```
A
/ \
B   C
\ /
 D
// TypeScript does not allow this, but if it did, D would have ambiguity in its inheritance.
```

Property Shadowing:

If a class defines a property with the same name as one in its base class, it can hide (shadow) the base class's property. This can make bugs that are difficult to find.

Code Example:

class Parent {
  name: string = 'Parent';
}

class Child extends Parent {
  name: string = 'Child'; // This shadows the 'name' property in 'Parent'
}

let child = new Child();
console.log(child.name); // Outputs: 'Child'

Constructor Binding:

In classes that extend other classes, the constructors have to call super() to make sure the base class is set up correctly. The order in which things are set up can cause problems if it's not done right.

Code Example:

class Base {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class Derived extends Base {
  constructor(name: string) {
    super(name); // Must call 'super()' before accessing 'this'.
    this.name = `Derived: ${name}`;
  }
}

Substitution Principle Violations:
If you can't use a subclass wherever you use its superclass, it may violate the Liskov Substitution Principle. This means the subclass does not behave as expected when used in place of the superclass, leading to errors.
- Code Example:
```
class Bird {
  fly() {
    // implementation for flying
  }
}

class Penguin extends Bird {
  fly() {
    throw new Error("Cannot fly");
  }
}

// Using a Penguin in place of a Bird might cause issues if we expect to call 'fly' method.
```
Increased Memory Overhead:
Each object created from a subclass includes all the data from the superclass. If the subclass doesn't need all the properties of the superclass, this can waste memory.
- Code Example:
```
class Animal {
  // Assume lots of properties
}

class Dog extends Animal {
  // Dog might not need all Animal properties, leading to wasted memory.
}
```
Refactoring Challenges:
Changing the structure of a base class is hard because it can affect every class that extends from it. This makes it difficult to make changes without breaking something.
- Code Example:
```
class Vehicle {
  // Many derived classes depend on Vehicle's implementation.
}

// Changing Vehicle can affect Car, Truck, Bike, etc.
class Car extends Vehicle {}
```
Single Responsibility Principle:
Subclasses often do more than one thing, especially if they inherit from a base class that does a lot. This can violate the principle that a class should have only one reason to change.
- Code Example:
```
class User {
  // User class has multiple responsibilities
}

class AdminUser extends User {
  // Inherits all User responsibilities, possibly adding more.
}
```
Implicit Dependencies:
When a class inherits from another, it might depend on the base class's behavior without that being clear in the code, making the codebase harder to understand.
- Code Example:
```
class Button {
  // Base class logic
}

class SaveButton extends Button {
  // Depends on the logic of Button in a way not obvious from the interface.
}
```

Base Class Over-generalization:

Making a base class too general to cover every scenario makes it complicated and can lead to a lot of unused code.

Code Example:

class Component {
  // Generic methods that might not be applicable to all subclasses
}

class Button extends Component {
  // Might not need everything from Component
}

Alternative Patterns:
Using composition instead of inheritance can give you more control and flexibility. With composition, you build classes out of other classes without creating a strict parent-child relationship.
- Code Example:
```
class Engine {
  // Engine functionality
}

class Car {
  private engine: Engine;

  constructor(engine: Engine) {
    this.engine = engine;
  }

  // Car functionality using Engine without inheriting from it.
}
```
TypeScript Specific: Decorator Impact:
Decorators enhance the behavior of classes, methods, or properties in TypeScript. However, they don't automatically apply to subclasses, which can lead to unexpected behaviors if not planned for.
- Code Example:
```
function Component(constructor: Function) {
  // Decorator logic
}

@Component
class Control {
  // Some behavior added by the decorator
}

class Button extends Control {
  // Does not inherit the decorator-applied behaviors
}
```