What are the Types of Inheritance in Java? Examples andTips to Master Inheritance

Inheritance in Java is the technique through which an object gets all the behaviors and properties of its parent object. As a result, you can build a new class based on an existing class. The new class is known as the child or sub-class, whereas the existing class is known as the parent or superclass. The child class can access and reuse all the members, including methods and fields of the parent class. The inheritance represents the ‘is-a’ relationship that indicates the parent-child relationship.

Here, you will learn about the five types of inheritance in Java and their examples.

Single Inheritance in Java

Single inheritance is one of the basic types of inheritance in Java that requires one parent class and one child class. Through this inheritance, you can extend one class from another by reusing the methods and fields of the parent class. It makes your code much easier to understand and helps update it.

For example, let your Animal class hold the attribute like eating fish. Now, a new class named Cat automatically receives this attribute using the single inheritance mechanism. This way, the child class Cat carries the attributes of the parent class Animal without the requirement of complex maintenance procedures.

Also, the Cat class has its own attribute, meow that is not inherited from the parent class.

class Animal{
void eat(){System.out.println(“Eating”);}
}
class Cat extends Animal{
void meow(){System.out.println(“Meowing”);}
}
public class Main{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat();
}}

class Bird{
void fly(){System.out.println("Flying");}
}
class Parrot extends Bird{
void talk){System.out.println("Talking");}
}
class BabyParrot extends Parrot{
void eat(){System.out.println("Eating");}
}
public class Main{
public static void main(String args[]){
BabyParrot p=new BabyParrot p();
p.eat();
p.talk();
p.fly();
}}

class Instrument {
    String type = "String Instrument";

    void showType() {
System.out.println("Instrument type: " + type);
    }
}
class Flute extends Instrument {
    void playFlute() {
System.out.println("Playing flute scales.");
    }
}
class Violin extends Instrument {
    void playViolin() {
System.out.println("Playing violin harmonies.");
    }
}
class Trumpet extends Instrument {
    void playTrumpet() {
System.out.println("Playing trumpet melodies.");
    }
}
public class Main {
    public static void main(String[] args) {
        Flute flt = new Flute();
flt.showType();     // Inherited from Instrument
flt.playFlute();   // Unique to Flute

        Violin vio = new Violin();
vio.showType();     // Inherited from Instrument
vio.playViolin();    // Unique to Violin

      Trumpet tpt = new Trumpet();
tpt.showType();     // Inherited from Instrument
tpt.playViolin();    // Unique to Trumpet
    }
}

class Cat
{
public void displayCat()
{
System.out.println("Two Cats");
}
}
interface MotherCat
{
public void show();
}
interface FatherCat
{
public void show();
}
public class Kitten extends Cats implements MotherCat, FatherCat
{
public void show()
{
System.out.println("MotherCat and FatherCat are Cats ");
}
public void displayKitten()
{
System.out.println("MotherCat and FatherCat have one Kitten");
}
public static void main(String args[])
{
Kitten kit = new Kitten();
System.out.println("Hybrid Inheritance in Java");
kit.show();
kit.displayKitten();
}
}

/ Interface 1
interface Student1 {
    void learn();
}
// Interface 2
interface Student2 {
    void learn();
}
// Class implementing both interfaces
class Test implements  Student1,  Student2 {

    // Overriding learn() method from both interfaces
    public void learn() {
System.out.println("Book Class");
    }

    // Main driver method
    public static void main(String args[]) {
        Test t = new Test();
t.learn();
    }
}

You can gain these facilities by implementing different types of inheritance in Java –

Code reusability: The first and foremost benefit you can gain is code reusability. The inheritance mechanism helps you avoid code redundancy. 

Flexibility: Types of inheritance in Java employ structural and hierarchical ways to organize your code. As a result, your code looks clean and easily represents the relationship between different classes.

Easy to maintain: The subclasses achieve the features of the superclass by inheritance. Thus, if you change the superclass, the subclasses will also reflect those changes. This makes your code easier to maintain. 

Simplified design: As you can extend the classes with the types of inheritance in Java, you don’t need to write the code from scratch. So, it helps to avoid unnecessary complications. 

You can acquire advanced programming knowledge by understanding the concept of numerous types of inheritance in Java. It supports levelling up your skills and remains competitive in the job market. Self-learning and practicing are great strategies for boosting your expertise in the types of inheritance in Java.

However, you should opt for professional computer science courses like the Executive Programme in full stack web development to drive your career on the right path. This course will provide you with more exposure to real-world applications through which you can understand the concepts of inheritance better!