Single Inheritance in Java

Benefits of Single Inheritance in Java

• Single inheritance makes the code easy to read and manage by following a clear structure. It also helps avoid repeating the same code.
   
• It supports code reusability, as the child class can use the methods and properties of the parent class.
   
• It allows better abstraction because the child class can have its own features along with those it inherits from the parent class.

Limitations of Single Inheritance in Java

• A class can extend only one parent class, which reduces flexibility in designing programs.
   
• It limits code reuse in cases where certain functions don’t fit well in a single hierarchy.
   
• It may lead to confusion or errors if different classes have methods with the same name but perform different tasks.

Examples of Single Inheritance in Java Programming

Let us take two examples of single inheritance:

Example 1:

• Java

Java

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

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // Inherited from Animal
        myDog.bark();
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Example 2:

• Java

Java

class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    void drawCircle() {
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Circle myCircle = new Circle();
        myCircle.draw(); // Inherited from Shape
        myCircle.drawCircle();
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Using Super() and Subclass Constructors in Single Inheritance in Java

In Java, when implementing single inheritance, the super() keyword is used in a subclass constructor to invoke the constructor of its superclass. This is crucial for initializing inherited attributes and ensuring proper construction of the object hierarchy.

Consider the following example:

• Java

Java

class Animal {
    String sound;

    Animal(String sound) {
        this.sound = sound;
    }

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

class Dog extends Animal {
    String breed;

    Dog(String sound, String breed) {
        super(sound); // Invoking superclass constructor
        this.breed = breed;
    }

    void displayInfo() {
        System.out.println("Dog breed: " + breed);
    }
}

class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Woof", "Labrador");
        myDog.makeSound(); // Inherited from Animal
        myDog.displayInfo();
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

In this example, the Dog class extends the Animal class. The super(sound) line in the Dog constructor invokes the constructor of the Animal class, initializing the sound attribute. This demonstrates the use of super() and subclass constructors in the context of single inheritance in Java.

Why Do We Need Java Inheritance?

Inheritance in Java makes the code well-structured, readable, and easy to manage. It helps developers avoid repeating the same code and supports better software design by allowing classes to build upon existing ones.

Below are the key reasons why Java inheritance is important:

1. Encapsulation of Common Features

In many programs, different classes may share some common variables or methods. Instead of writing the same code in every class, we can keep these shared elements in a parent class. The child classes can then use or update them as needed. This helps in organizing the code properly and makes updates easier in the future.
 

2. Polymorphism for Flexible Behavior

Inheritance allows polymorphism, which means methods in the parent class can behave differently when used by child classes. This flexibility makes the program more dynamic and helps us write cleaner and smarter code. We can define a method once in the parent class and then change its behavior in the child class if needed.
 

3. Reusability of Code

One of the biggest advantages of inheritance is code reusability. Instead of writing similar code again and again, we can define it once in a base class and use it wherever required. This not only saves development time but also reduces the chance of bugs.
 

4. Better Maintainability

Since common logic is written only once, updating or fixing it becomes much easier. If you make changes in the parent class, all child classes that inherit from it will automatically get those updates. This makes the maintenance of large projects faster and simpler.
 

5. Improves Project Structure

Using inheritance gives your project a logical structure. It allows you to create a hierarchy of classes, where higher-level classes provide general behavior and lower-level classes handle more specific tasks. This makes the application easier to scale and understand for any developer working on the project.
 

Frequently Asked Questions

What is a real life example of single inheritance in Java?

An example is a "Car" class inheriting from a "Vehicle" class. The "Car" class gains properties like speed and methods like start() from the "Vehicle" class.

What is inheritance single & multilevel in Java?

Single inheritance involves a class inheriting from one superclass, while multilevel inheritance includes a chain of classes, each extending the one above it. In Java, this forms a hierarchy facilitating code organization and reuse.

What are the 4 types of inheritance in Java?

The four types of inheritance in Java are single, multilevel, hierarchical, and hybrid. Single, multilevel, and hierarchical are straightforward, while hybrid involves combining these types, typically using interfaces.

Conclusion

In this article, we discussed Single Inheritance in Java, an important concept in Object-oriented programming, how it works, the syntax, and examples of implementing single inheritance in Java. 

You can learn more about Object-Oriented Programming and related concepts here.

• Has-A Relationship in Java
• Super Keyword In Java
• Fibonacci Series in Java
• Delegation Event Model in Java
• Swap Function in Java
• Access modifiers in java