Inheritance in Java Programming with examples

Inheritance in Java Programming: In Our Previous Post, we have discussed different Java access modifiers, and in this post, we are going to discuss one of the main OOPS concepts of Java called Inheritance.

If you want to be a Good Java developer, then you must have good knowledge of Java OOPS concepts like Inheritance, Abstraction, Encapsulation, and Polymorphism. So in this post, we are going to discuss one of the important concepts of the OOPS concept that is Inheritance, and we are also going to learn how we can achieve inheritance in Java programming language?

In this post. We are going to discuss:

• Introduction of Inheritance
• Types Of Inheritance
• Important Fact about inheritance

Introduction Of Inheritance in Java

the process by which one class acquires the data member (Variables) and member functions (methods) of other class that process is called inheritance. The main benefits of Inheritance are it provides the code reusability so that a class can extend the properties and behaviors of an existing class. After that, they need to write only the unique new features.

Important Terminology Of Inheritance

• Parent Class: A Class whose properties and member functions are inherited by another class is know a parent class, superclass or base class.
• Child Class: A Class who extends the properties and behaviors of other class is called child class, subclass or derived class.

Inheritance Syntax in Java

For Inherit the data member and member functions, we are using a keyword “Extends”. Suppose there are two classes (Class1 & Class2) present, where class2 inheriting the properties and methods of class1, Then we have to write like below

Class class2 extends class1
{
//Body
}

Types of Inheritance in Java

In Java, there are mainly five types of inheritance are there, that is:

• Single Inheritance
• Multi-Level Inheritance
• Hierarchical inheritance
• Hybrid Inheritance
• Multiple Inheritance

Single Inheritance in Java

In this type of inheritance, there are two classes present one is parent class and another one is child class. Here child class inherits the properties of parent class into child class. By this, we can reuse the existing code and also we can add new features in the child class.

Single Inheritance Example:

package com.SoftwareTestingo.JavaBasics;

class Single_ParentClass
{
   public void parent_method()
   {
      System.out.println("Parent Class Method");
   }
}
public class Single_Inheritance extends Single_ParentClass
{
   public void child_method()
   {
      System.out.println("Child class Method");
   }
   public static void main(String[] args) 
   {
      Single_Inheritance obj=new Single_Inheritance();
      obj.parent_method(); //Calling Parent Class Method
      obj.child_method();  //Calling Child Class Method
   }
}

Output:

Parent Class Method
Child class Method

Multi-Level Inheritance in Java

When a Class had more than one parent class, that type of inheritance is called multilevel inheritance. If you saw the pic, you can find that class b inherit member and methods of class a and Class c extend class b.

Multi Level Inheritance:

package com.SoftwareTestingo.JavaBasics;

class MultiLevel_ParentClass
{
   public void parent_method()
   {
      System.out.println("Parent Class Method");
   }
}
class Middle_Class extends MultiLevel_ParentClass
{
   public void middleClass_method()
   {
      System.out.println("Middle Class Method");
   }
}
public class MultiLevel_Inheritance extends Middle_Class
{
   public void child_method()
   {
      System.out.println("Child Class Method");
   }
   public static void main(String[] args) 
   {
      MultiLevel_Inheritance obj=new MultiLevel_Inheritance();
      obj.parent_method(); //Calling Grand Parent Method
      obj.middleClass_method(); // Calling Parent Method
      obj.child_method();  //Calling Child Method	
   }
}

Output:

Parent Class Method
Middle Class Method
Child Class Method

Hierarchical Inheritance in Java

This type of inheritance, one class is served as a base class, and multiple subclasses extend the features and methods of that base class. If you saw in the diagram, then Class A Is the base class and Class B, Class C, And Class D are the subclasses who extends Class A.

Hierarchical Inheritance Example:

package com.SoftwareTestingo.JavaBasics;
class parent_class
{
   public void parent_method()
   {
      System.out.println("Parent Class Method");
   }
}
class ClassA extends parent_class
{
   public void classAMethod()
   {
      System.out.println("Class A Method");
   }
}
class ClassB extends parent_class
{
   public void classBMethod()
   {
      System.err.println("Class B Method");
   }
}
class ClassC extends parent_class
{
   public void ClassCMethod()
   {
      System.out.println("Class C Method");
   }
}
public class Hierarchical_Inheritance 
{
   public static void main(String[] args)
   {
      ClassA obj1=new ClassA();
      ClassB obj2=new ClassB();
      ClassC obj3=new ClassC();
      
      // Call All Classes Method by Using above objects
      
      obj1.classAMethod();
      obj2.classBMethod();
      obj3.ClassCMethod();
   }
}

Output:

Class A Method
Class B Method
Class C Method

Multiple Inheritance in Java

In Multiple inheritances, one class has more than one base class, and it inherits features from all its parent class. But Java doesn’t support multiple inheritances with classes, But we can achieve multiple inheritances by implementing Interface.

Multiple Inheritance Example:

package com.SoftwareTestingo.JavaBasics;

class ParentClass1
{
   public void parentMethod1()
   {
      System.out.println("Parent Method Called");
   }
}
class ParentClass2
{
   public void parentMethod2()
   {
      System.out.println("Parent Method Called");
   }
}
//Java Does Not Support Multiple Inheritance
//public class Multiple_Inheritance extends ParentClass1, ParentClass2
//{
//	public static void main(String[] args) 
//	{
//		Multiple_Inheritance obj=new Multiple_Inheritance();
//		obj.parentMethod1();
//		obj.parentMethod2();
//	}
//}

You Will get below errors:

Hybrid Inheritance in Java

The Combination of one or more above types of inheritance is called Hybrid inheritance.

Points to Remember

• Multiple Inheritance is Not allowed in Java: Multiple inheritances means a class has more than one parent class. Because of these features, there is a chance of ambiguity situation that’s why multiple inheritances are not permitted in Java.

Note: Multiple inheritances are not permitted in Java, but you can achieve that by using Interface.

• Cyclic Inheritance Is not allowed: It is a type of inheritance where a class extends itself or by some loop. Such kind of inheritance is not allowed in Java because of this leads to ambiguity.

• Private Members Are Not Inherited
• Constructors Cant Not Inherited In Java

Constructors can not be inherited in Java as the subclass have a different name. But when we are creating the object of the subclass that time default constructor of parent class called by default. It is all happening because when the child class constructor called, that time the first statement of a child class constructor is a super keyword that’s why when we create a child class object the parent class-default constructor also called automatically.

Because of the super keyword, we can call the parent class constructor other then this we are not permitted to call the parent class constructor directly.

	Default	Private	Protected	Public
Same Class	Yes	Yes	Yes	Yes
Same Package Subclass	Yes	No	Yes	Yes
Same Package Non-Subclass	Yes	No	Yes	Yes
Different Package Subclass	No	No	Yes	Yes
Different Package Non-Subclass	No	No	No	Yes

Ref: article