Inheritance

Overview

Definition

Inheritance is a mechanism by which a new class (subclass or derived class) inherits properties (fields and methods) and behaviors from an existing class (superclass or base class). The subclass can extend or modify the behavior of the superclass.

Use Cases

Creating specialized classes that share common attributes and behaviors.

Extending the functionality of existing classes without modifying their code.

Implementing polymorphism, allowing objects of different classes to be treated as objects of a common superclass.

Pros & Cons

👍

Modularity

Classes can be organized hierarchically, aiding in code management.

Reusability

Reusing existing code reduces redundancy and development time.

Efficiency

By inheriting methods and fields, new classes can leverage existing functionality.

Polymorphism

Subclasses can be treated as instances of their superclass, allowing dynamic method invocation.

👎

Tight Coupling

Changes to the superclass can affect its subclasses, leading to unintended consequences.

Inheritance Hierarchy Complexity

Deep hierarchies can be intricate and challenging to manage.

Fragile Base Class Problem

Modifications to the base class can inadvertently break subclasses.

class inheritance Syntax

Pseudocode

class Animal:
    method speak()  // Common method, to be overridden

class Dog extends Animal:
    method speak()
        output "Woof!"

class Cat extends Animal:
    method speak()
        output "Meow!"

C++

#include <iostream>

class Animal {
public:
    virtual void speak() {
        std::cout << "Some sound..." << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    Animal *a;
    Dog d;
    Cat c;

    a = &d;
    a->speak(); // Output: Woof!

    a = &c;
    a->speak(); // Output: Meow!

    return 0;
}

Python

class Animal:
    def speak(self):
        print("Some sound...")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

a = Animal()
d = Dog()
c = Cat()

a.speak()  # Output: Some sound...
d.speak()  # Output: Woof!
c.speak()  # Output: Meow!

Java

class Animal {
    void speak() {
        System.out.println("Some sound...");
    }
}

class Dog extends Animal {
    void speak() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    void speak() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        Dog d = new Dog();
        Cat c = new Cat();

        a.speak(); // Output: Some sound...
        d.speak(); // Output: Woof!
        c.speak(); // Output: Meow!
    }
}

Rust

trait Animal {
    fn speak(&self);
}

struct Dog;

impl Animal for Dog {
    fn speak(&self) {
        println!("Woof!");
    }
}

struct Cat;

impl Animal for Cat {
    fn speak(&self) {
        println!("Meow!");
    }
}

fn main() {
    let d = Dog;
    let c = Cat;

    d.speak(); // Output: Woof!
    c.speak(); // Output: Meow!
}

Golang

package main

import "fmt"

type Animal interface {
    Speak()
}

type Dog struct{}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

type Cat struct{}

func (c Cat) Speak() {
    fmt.Println("Meow!")
}

func main() {
    var a Animal

    d := Dog{}
    c := Cat{}

    a = d
    a.Speak() // Output: Woof!

    a = c
    a.Speak() // Output: Meow!
}

Output

Python & Java

Some sound...
Woof!
Meow!

C++, Rust, and Golang

Some sound...
Woof!
Meow!

Comparing & Contrast

Language	Inheritance Syntax	Overriding Method	Polymorphism
C++	class Derived : public Base	virtual method, override keyword	Yes
Python	class Derived(Base):	def method, method overriding	Yes
Java	class Derived extends Base	void method, @Override annotation	Yes
Rust	impl Trait for Struct	Trait implementation	Yes
Go	type Struct struct { }	Method implementation	Yes