What is Inheritance in Java: Types of Inheritance in Java

// Parent class (Superclass)
class ParentClass {
  // Fields and methods
}// Child class (Subclass) that inherits from ParentClass
class ChildClass extends ParentClass {
 // Additional fields and methods
}

Example

// Parent class (Superclass)class Animal {
  String name;
  int age;  
 public Animal(String name, int age) {
    this.name = name;
    this.age = age;
  }  
 public void speak() {
    System.out.println(name + " makes a sound.");
  }
}// Child class (Subclass) that inherits from Animal
class Dog extends Animal {
  String breed;  public Dog(String name, int age, String breed) {
    super(name, age); // Call the constructor of the parent class
    this.breed = breed;
  }  // Override the speak() method
  @Override
  public void speak() {
    System.out.println(name + " barks loudly!");
  }  public void fetch() {
    System.out.println(name + " fetches a ball.");
  }
}public class InheritanceExample {
  public static void main(String[] args) {
    // Create instances of Animal and Dog
    Animal genericAnimal = new Animal("Generic", 5);
    Dog myDog = new Dog("Buddy", 3, "Golden Retriever");    // Call methods
    genericAnimal.speak(); // Output: Generic makes a sound.
    myDog.speak(); // Output: Buddy barks loudly!
    myDog.fetch(); // Output: Buddy fetches a ball.
  }
}

Java inheritance is shown in the Java Online Compiler. The Dog class is a subclass that derives from Animal, overrides the speak() function, and adds a fetch() method. The Animal class serves as the parent class and has attributes and a speak() method. Instances of both classes are created by the main method, demonstrating polymorphism as they call their respective speak() methods and generating output specific to their behaviors.

Output

Generic makes a sound.
Buddy barks loudly!
Buddy fetches a ball.

Access Modifiers in Java

1. Default Access Modifier: The parent class is only accessible inside the Java project's package currently in use, but not outside of the package.
2. Private Access Modifier: The methods of private modifiers can not be accessed by other users other than their native class.
3. Protected Access Modifier: The methods and the members of the protected class are only accessible and visible to their classes and their inherited classes.
4. Public Access Modifier: It is used for making a method or data member accessible for everyone and every platform.

To learn Access Modifiers in detail, refer to Access Modifiers in Java

Method Overriding in Java Inheritance

When you redefine any base class method with the same signature i.e. same return type, number, and type of parameters in the derived class, it is known as method overriding in Java. In this case, the method in the subclass overrides the method in the superclass.

Example of Method Overriding in Java

class DotNetTricks {
    public void print() { // overridden function
        System.out.println("Welcome to DotNetTricks");
    }
}

class ScholarHat extends DotNetTricks {
    @Override
    public void print() { // overriding function
        System.out.println("Welcome to ScholarHat");
    }
}

public class Main {
    public static void main(String[] args) {
        ScholarHat obj1 = new ScholarHat();

        // Call the print() function of the ScholarHat class
        obj1.print();
    }
}

In the above code, the base class Scholarhat overrides the print() function of the parent class, DotNetTricks. When you create an object of ScholarHat and call its print() function, it executes the version of the function defined in the ScholarHat class.

Output

Welcome to ScholarHat

super Keyword in Java Inheritance

In the above topic we saw that when the same method is defined in both the base class and the derived class, the method in the subclass overrides the one in the superclass. In such cases, the super keyword in Java is used to call the method of the parent class from the method of the child class.

class DotNetTricks {
    public void print() { // overridden function
        System.out.println("Welcome to DotNetTricks");
    }
}

class ScholarHat extends DotNetTricks {
    @Override
    public void print() { // overriding function

   // call method of the superclass
    super.print();
        System.out.println("Welcome to ScholarHat");
    }
}

public class Main {
    public static void main(String[] args) {
        ScholarHat obj1 = new ScholarHat();

        // Call the print() function 
        obj1.print();
    }
}

Here, the super keyword in the Java Online Editor is used to call the print() method present in the superclass.

Output

Welcome to DotNetTricks
Welcome to ScholarHat

Types of Inheritance in Java

There are five types of Inheritance in Java

1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance

1. Single Inheritance in Java

This is a single-level Inheritance with one subclass with the properties of the superclass.

Example

class Animal
  { 
  void sleep(){System.out.println("sleeping...");} 
  } 
  class Dog extends Animal
  { 
  void bark(){System.out.println("barking...");} 
  } 
  class TestInheritance
  { 
  public static void main(String args[])
  { 
  Dog d=new Dog(); 
  d.bark(); 
  d.sleep(); 
  }
  } 

The Dog class in this example inherits from the Animal class to demonstrate inheritance in Java. The TestInheritance class creates a Dog instance and calls the bark() and sleep() methods to show how a subclass inherits functionality from its superclass. The Dog class adds a bark() method.

Output

barking…
sleeping…

2. Multi-Level Inheritance in Java

If there are 3 classes named A, B, and C in the Java toolkit, then class B inherits the properties of class A, and class C inherits the properties of class B. This happens in multilevel inheritance in Java.

Multi-Level Inheritance in Java Example

class Animal
  { 
  void eat(){System.out.println("eating...");} 
  } 
  class Dog extends Animal{ 
  void sleep(){System.out.println("sleeping...");} 
  } 
  class BabyDog extends Dog
  { 
  void weep(){System.out.println("weeping...");} 
  } 
  class TestInheritance2
  { 
  public static void main(String args[])
  { 
  BabyDog d=new BabyDog(); 
  d.weep(); 
  d.sleep(); 
  d.eat(); 
  }
  }

The 'BabyDog' class in this example illustrates multi-level inheritance in Java; it derives from the 'Dog' class, which in turn derives from the 'Animal' class. The 'BabyDog' object has access to and may call methods from all three types, showing how inheritance establishes a hierarchy of classes with similar functionality.

Output

weeping…
sleeping…
eating…

3. Hierarchical Inheritance in Java

It multiplied one parent class with their child classes. This type of Inheritance in Java helps to reduce the code length and also increases the "code modularity".

Example

class Animal
  { 
  void eat(){System.out.println("eating...");} 
  } 
  class Dog extends Animal
  { 
  void sleep(){System.out.println("sleeping...");} 
  } 
  class Cat extends Animal
  { 
  void meow(){System.out.println("meowing...");} 
  } 
  class TestInheritance3
  { 
  public static void main(String args[])
  { 
  Cat c=new Cat(); 
  c.meow(); 
  c.eat(); 
  //c.bark();//C.T.Error 
  }
  } 

This Java sample in the Java Compiler explains basic inheritance. As a result of the 'Cat' class' inheritance from the 'Animal' class, instances of the 'Cat' class can access and use the parent class' methods. A compile-time error (C.T.Error) is generated when attempting to call a method from a class that is unrelated to the one being called, such as "bark()," which is not a member of "Animal" or "Cat."

Output

meowing…
eating…

Read More: Hierarchical Inheritance in Java

4. Multiple Inheritance (Through Interfaces) in Java

A class can inherit behaviors and method signatures from various interfaces using multiple inheritances through interfaces, which encourages code reuse and flexibility. Interfaces ensure that classes follow predetermined behaviors by defining method contracts without implementing them.

Example

// Define two interfacesinterface Animal {
  void eat();
  void sleep();
}interface Bird {
  void fly();
}// Create a class that implements both interfaces
class Sparrow implements Animal, Bird {
  @Override
  public void eat() {
    System.out.println("Sparrow is eating.");
  }  @Override
  public void sleep() {
    System.out.println("Sparrow is sleeping.");
  }  @Override
  public void fly() {
    System.out.println("Sparrow is flying.");
  }
}public class Main {
  public static void main(String[] args) {
    Sparrow sparrow = new Sparrow();
    sparrow.eat(); // Calls the eat() method from the Animal interface
    sparrow.sleep(); // Calls the sleep() method from the Animal interface
    sparrow.fly(); // Calls the fly() method from the Bird interface

  }

}

The "Animal" and "Bird" interfaces are defined in this code, along with the class "Sparrow," which implements both interfaces. The 'eat()','sleep()', and 'fly()' methods are implemented by the 'Sparrow' class. It generates a "Sparrow" object and invokes its methods in the "main" method to show multiple inheritance through interfaces.

Output

Sparrow is eating.
Sparrow is sleeping.
Sparrow is flying.

Read More: Multiple Inheritance in Java

5. Hybrid Inheritance in Java

When a class derives from numerous classes by combining various inheritance types, this is referred to as hybrid inheritance in Java. Java enables both single and multiple inheritance through classes and interfaces. When a class uses hybrid inheritance, it can derive from a variety of classes, some of which are descended from through interface inheritance and others through class inheritance.

Example

// Base class
class Animal {
  void eat() {
    System.out.println("Animal is eating.");
  }
}// Interface for flying behavior
interface Flying {
  void fly();
}// Interface for swimming behavior
interface Swimming {
  void swim();
}// Derived class inheriting from Animal and implementing Flying interface
class Bird extends Animal implements Flying {
  @Override
  public void fly() {
    System.out.println("Bird is flying.");
  }
}// Derived class inheriting from Animal and implementing Swimming interface
class Fish extends Animal implements Swimming {
  @Override
  public void swim() {
    System.out.println("Fish is swimming.");
  }
}// Derived class inheriting from Bird and Fish
class FlyingFish extends Bird implements Swimming {
  @Override
  public void swim() {
    System.out.println("FlyingFish is swimming.");
  }
}public class Main {
  public static void main(String[] args) {
    Bird bird = new Bird();
    bird.eat();
    bird.fly();    Fish fish = new Fish();
    fish.eat();
    fish.swim();    FlyingFish flyingFish = new FlyingFish();
    flyingFish.eat();
    flyingFish.fly();
    flyingFish.swim();
}
} 

The code in the Java Playground shows how to create a class hierarchy using interfaces and class inheritance. It has two interfaces, 'Flying' and 'Swimming', which represent behaviors, as well as an 'Animal' base class with a 'feed' method. The derived classes "Bird" and "Fish" implement the "Flying" and "Swimming" interfaces, respectively, and both classes inherit from "Animal." The 'FlyingFish' class also implements 'Swimming' and further inherits from 'Bird'. To show method overriding and interface implementation, instances of these classes are created in the 'Main' class and their methods are called.

Output

Animal is eating.
Bird is flying.
Animal is eating.
Fish is swimming.
Animal is eating.
Bird is flying.
FlyingFish is swimming.

Why Do We Need Java Inheritance?

• Code reuse: All subclasses share the code that was written for the superclass. The parent class code can be used directly by child classes.
• Method Overriding: The only way to override a method is through inheritance. It is one approach for Java to implement run-time polymorphism.
• Abstraction: Through inheritance, we may reach the concept of abstraction, which frees us from having to provide all the details. Abstraction only makes the user aware of the capability.

Advantages Of Inheritance in Java

• Code reuse is made possible by inheritance, which lowers the amount of new code required. Reduced code duplication results from the subclass's ability to reuse the superclass's properties and functions.
• Inheritance enables the development of abstract classes that specify a common interface for a collection of related classes. This encourages abstraction and encapsulation, which makes it simpler to extend and maintain the code.
• A class hierarchy can be created through inheritance and utilized to represent the relationships between actual objects in the real world.
• Polymorphism, or the capacity for a thing to take on various forms, is made possible by inheritance. The superclass's methods can be overridden by subclasses, giving them the flexibility to alter how they behave.

Disadvantages of Inheritance in Java

• Inheritance may result in a more difficult-to-understand and complex code. This is particularly true if there are many inheritances used or if the inheritance hierarchy is complex.
• Changes to the superclass without affecting the subclass are challenging to do because inheritance generates a tight coupling between the two classes.

Summary

In Java, inheritance is when one class can inherit the attributes and methods of another. While each type of inheritance has its unique benefits, they all ultimately allow for code reusability making programs more efficient. The understanding and application of inheritance concepts play a vital role in Full Stack Java Developer Course, enabling developers to design and implement efficient, scalable, and maintainable Java programs.