Inheritance vs Composition in Java

Inheritance 

Introduction :

Inheritance is a fundamental concept in Java and other object-oriented programming languages. It allows a class to inherit the properties and behaviors of another class, thereby promoting code reuse and creating a hierarchical relationship between classes. In Java, inheritance is achieved using the extends keyword. The class that is being inherited from is called the superclass or base class, and the class inheriting from it is called the subclass or derived class.

Inheritance basic syntax:

class Superclass {
    // Fields, methods, and nested classes
}

class Subclass extends Superclass {
    // Additional fields, methods, and nested classes,
    // along with inherited members
}

Inheritance example:

// Superclass
class Animal {
    String species;
    int age;

    void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

// Subclass inheriting from Animal
class Dog extends Animal {
    String breed;

    void bark() {
        System.out.println("Woof! Woof!");
    }
}

There are four types of inheritance in java . The types are given below:

// Superclass
class Vehicle {
    String brand;
    String model;

    Vehicle(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }

    void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Model: " + model);
    }
}

// Subclass inheriting from Vehicle
class Car extends Vehicle {
    int numberOfDoors;

    Car(String brand, String model, int numberOfDoors) {
        super(brand, model);
        this.numberOfDoors = numberOfDoors;
    }

    void displayInfo() {
        super.displayInfo();
        System.out.println("Number of doors: " + numberOfDoors);
    }
}

// Subclass inheriting from Car
class ElectricCar extends Car {
    int batteryCapacity;

    ElectricCar(String brand, String model, int numberOfDoors, int batteryCapacity) {
        super(brand, model, numberOfDoors);
        this.batteryCapacity = batteryCapacity;
    }

    void displayInfo() {
        super.displayInfo();
        System.out.println("Battery Capacity: " + batteryCapacity + " kWh");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle("Generic Brand", "Generic Model");
        vehicle.displayInfo();

        System.out.println("---------------------------");

        Car car = new Car("Toyota", "Corolla", 4);
        car.displayInfo();

        System.out.println("---------------------------");

        ElectricCar electricCar = new ElectricCar("Tesla", "Model S", 4, 75);
        electricCar.displayInfo();
    }
}

interface Swimmer {
    void swim();
}

interface Flyer {
    void fly();
}

class Bird implements Swimmer, Flyer {
    // Implementation of swim() and fly() methods
}

class Animal {
    // Fields and methods
}

class Cat extends Animal {
    // Additional fields and methods specific to Cat
}

class Dog extends Animal {
    // Additional fields and methods specific to Dog
}

class Animal {
    // Fields and methods
}

class Mammal extends Animal {
    // Additional fields and methods specific to Mammal
}

class Dog extends Mammal {
    // Additional fields and methods specific to Dog
}

Composition

class Component {
    // Fields and methods of the component class
}

class Composite {
    private Component component;

    Composite(Component component) {
        this.component = component;
    }

    // Methods and behaviors of the composite class, working with the 'component' object
}

There are mainly two types of Composition in java:

class Engine {
    // Engine class code
}

class Car {
    private Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }

    // Car class code using the 'engine' object
}

class Address {
    // Address class code
}

class Person {
    private Address address;

    Person(Address address) {
        this.address = address;
    }

    // Person class code using the 'address' object
}