Inheritence in Java explained with example.

 Inheritance is a fundamental concept in object-oriented programming, and it is supported in Java through the use of the “extends” keyword. This feature allows developers to create new classes that inherit properties and methods from existing classes, making it easier to reuse code and build more complex systems.

For example, let’s say we have a superclass called “Animal” that has properties like “name” and “age” and methods like “eat()” and “sleep()”.

class Animals {
    private String name;
    private int age;

    public Animals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void eat() {
        System.out.println("Animal is eating.");
    }

    public void sleep() {
        System.out.println("Animals is sleeping.");
    }
}

We can then create a subclass called “Dogs” that inherits from “Animals” and adds its own properties like “breed” and methods like “bark()”.

class Dogs extends Animals {
    private String breed;

    public Dogs(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

The “Dogs” class automatically has access to the “name” and “age” properties and the “eat()” and “sleep()” methods of the “Animals” class, and we can add new functionality specific to dogs without having to duplicate code.

In addition to allowing for code reuse, inheritance also enables polymorphism. Polymorphism means that a subclass can be used wherever a superclass is expected. This allows for greater flexibility in our code, as we can write methods that work with any class that inherits from a specific superclass, rather than having to write separate methods for each individual class.

For example, we can create a method that accepts an Animal object and call its eat() method. We can pass an object of Dogs class and it will call the eat() method from the Animals class.

public void feedAnimal(Animals animal) {
    animal.eat();
}

However, inheritance also has its downsides, such as the “Fragile Base Class” problem. Changes in the superclass may cause unexpected changes in the subclasses that inherit from it, and can result in a lot of bugs. Therefore it is important to think carefully about the relationships between classes and to design our inheritance hierarchies in a way that is both easy to understand and maintain.

In conclusion, Inheritance is a powerful feature in Java that allows developers to reuse code and build more complex systems. It also enables polymorphism, which allows for greater flexibility in our code. However, it is important to use it with caution and to think carefully about the relationships between classes.