Inheritance In Dart

Introduction

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class to inherit properties and behavior from another class. In Dart, inheritance enables code reusability, promotes a hierarchical structure, and supports polymorphism. By leveraging inheritance, developers can create a more organized and scalable codebase.

History/Background

Inheritance has been a core feature of object-oriented programming languages since their inception. Dart, being an OOP language itself, introduced inheritance from its early versions to facilitate code structuring, enhance modularity, and promote the reuse of code.

Syntax

In Dart, the syntax for inheritance is achieved using the extends keyword. Here's a basic syntax template:

class ParentClass {
  // properties and methods
}

class ChildClass extends ParentClass {
  // additional properties and methods
}

• ✅ The ChildClass inherits all the properties and methods of the ParentClass.
• ✅ The extends keyword establishes an "is-a" relationship between the child and parent classes, indicating that the child class is a specific type of the parent class.

Key Features

• ✅ Allows classes to inherit properties and methods from a parent class.
• ✅ Supports code reusability and promotes a hierarchical structure.
• ✅ Enables polymorphism and method overriding.
• ✅ Facilitates creating specialized classes based on more general ones.

Example 1: Basic Inheritance

Example
Copy
class Animal {
  void eat() {
    print('Animal is eating.');
  }
}

class Dog extends Animal {
  void bark() {
    print('Dog is barking.');
  }
}

void main() {
  Dog dog = Dog();
  dog.eat(); // inherited method
  dog.bark(); // own method
}
Try it Yourself

Output:

Animal is eating.
Dog is barking.

Example 2: Method Overriding

class Shape {
  void draw() {
    print('Drawing a shape.');
  }
}

class Circle extends Shape {
  @override
  void draw() {
    print('Drawing a circle.');
  }
}

void main() {
  Circle circle = Circle();
  circle.draw(); // overridden method
}

Output:

Drawing a circle.

Example 3: Constructor Inheritance

class Vehicle {
  String model;

  Vehicle(this.model);

  void showModel() {
    print('Model: $model');
  }
}

class Car extends Vehicle {
  Car(String model) : super(model);
}

void main() {
  Car car = Car('Tesla Model S');
  car.showModel();
}

Output:

Model: Tesla Model S

Common Mistakes to Avoid

1. Forgetting to Use the `super` Keyword

Problem: A common mistake is to forget to call the superclass constructor when overriding the constructor in a subclass.

// BAD - Don't do this
class Animal {
  Animal(String name) {
    print("Animal: $name");
  }
}

class Dog extends Animal {
  Dog(String name) {
    print("Dog: $name");
  }
}

Solution:

// GOOD - Do this instead
class Animal {
  Animal(String name) {
    print("Animal: $name");
  }
}

class Dog extends Animal {
  Dog(String name) : super(name) {
    print("Dog: $name");
  }
}

Why: Not calling super means that the parent's constructor isn't executed, which can lead to incomplete initialization of the object. Always ensure that the superclass constructor is invoked if it requires parameters.

2. Overriding Methods Without Using `@override`

Problem: Beginners often override methods in subclasses without using the @override annotation, leading to confusion and potential errors.

// BAD - Don't do this
class Animal {
  void speak() {
    print("Animal sound");
  }
}

class Dog extends Animal {
  void speak() {
    print("Bark");
  }
}

Solution:

// GOOD - Do this instead
class Animal {
  void speak() {
    print("Animal sound");
  }
}

class Dog extends Animal {
  @override
  void speak() {
    print("Bark");
  }
}

Why: Using @override clarifies that you intend to override a method from the superclass, helping to catch errors if the method signature does not match. It also improves code readability.

3. Misunderstanding Polymorphism

Problem: Beginners often expect that method calls will resolve to the subclass implementation without understanding polymorphism.

// BAD - Don't do this
class Animal {
  void speak() {
    print("Animal sound");
  }
}

class Dog extends Animal {
  void speak() {
    print("Bark");
  }
}

void main() {
  Animal animal = Dog();
  animal.speak(); // They expect "Animal sound"
}

Solution:

// GOOD - Do this instead
class Animal {
  void speak() {
    print("Animal sound");
  }
}

class Dog extends Animal {
  @override
  void speak() {
    print("Bark");
  }
}

void main() {
  Animal animal = Dog();
  animal.speak(); // Correctly prints "Bark"
}

Why: The expectation that the superclass method will be called is misguided. When a method is overridden, the subclass method is called based on the actual object type during runtime. Understanding polymorphism is crucial for effective inheritance usage.

4. Using Inheritance Instead of Composition

Problem: Some beginners misuse inheritance when composition would be more appropriate, leading to tightly coupled code.

// BAD - Don't do this
class Engine {
  void start() {
    print("Engine starting");
  }
}

class Car extends Engine {
  void drive() {
    print("Car is driving");
  }
}

Solution:

// GOOD - Do this instead
class Engine {
  void start() {
    print("Engine starting");
  }
}

class Car {
  final Engine engine;

  Car(this.engine);

  void drive() {
    engine.start();
    print("Car is driving");
  }
}

Why: Inheritance implies an "is-a" relationship, while composition implies a "has-a" relationship. Using composition allows for more flexible and maintainable code. Consider whether inheritance is truly the right model for your design.

5. Ignoring Abstract Classes and Interfaces

Problem: Beginners may create concrete classes without realizing they should be using abstract classes or interfaces for better design.

// BAD - Don't do this
class Vehicle {
  void speed();
}

class Car extends Vehicle {
  void speed() {
    print("Car speed");
  }
}

Solution:

// GOOD - Do this instead
abstract class Vehicle {
  void speed();
}

class Car implements Vehicle {
  @override
  void speed() {
    print("Car speed");
  }
}

Why: Abstract classes and interfaces allow for more flexible designs and enforce a contract for subclasses. They help in achieving loose coupling and better code organization.

Best Practices

1. Use `@override` Annotation

Always use the @override annotation when overriding methods. This practice helps catch errors early and improves code readability by clearly indicating overridden methods.

2. Favor Composition Over Inheritance

When designing your classes, consider whether composition might be more appropriate than inheritance. This leads to more maintainable and flexible code. For instance, use delegation to achieve shared behavior.

3. Keep Inheritance Hierarchies Shallow

Limit the depth of your inheritance hierarchies to avoid complexity and maintainability issues. A hierarchy that is too deep can lead to confusion and tightly coupled code.

4. Prefer Abstract Classes for Shared Behavior

Use abstract classes when you want to define a common template for subclasses. This ensures that all subclasses implement specific methods and can share common functionality.

5. Use Constructors Wisely

Always invoke the superclass constructor in your subclass constructor where necessary. This ensures that the base class is properly initialized. Use the super keyword to pass parameters.

6. Document Your Classes and Methods

Always provide documentation for your classes and methods, especially when using inheritance. This clarifies the intended use of the class and its methods, helping other developers (and future you) understand the design.

Key Points