Code360 powered by Coding Ninjas X Naukri.com. Code360 powered by Coding Ninjas X Naukri.com
Table of contents
1.
Introduction
2.
Class Hierarchy
2.1.
Types of classes
2.2.
Simple Inheritance
2.2.1.
C++ Program 
2.2.2.
Output
2.2.3.
Java Program 
2.2.4.
Output
2.3.
Multiple Inheritance
2.3.1.
C++ Program
2.3.2.
Output
2.3.3.
Java Program
2.4.
Level inheritance
2.4.1.
C++ Program
2.4.2.
Output
2.4.3.
Java Program
2.4.4.
Output
3.
Frequently Asked Questions
4.
Conclusion
Last Updated: Mar 27, 2024

Difference between Inheritance in C++ and Java

Author Aman Thakur
0 upvote
Roadmap to SDE career at Amazon
Speaker
Anubhav Sinha
SDE-2 @
25 Jun, 2024 @ 01:30 PM

Introduction

Inheritance is a very crucial component of object-oriented programming that works in a similar fashion to how we inherit traits from our parents. In object-oriented programming, properties and behaviours of a class—that is, the data and methods of a class—are referred to as characteristics.Because inheritance allows objects to inherit properties and actions from other objects, it is a cornerstone of object-oriented programming.

Inheritance allows you to spread control over object development and maintenance. A programmer, for example, may be in charge of generating and maintaining the student object. The graduate student object might be created and maintained by another programmer. When a modification that affects all students happens, the student object is updated, and the graduate student object inherits the changes. Because the graduate student object inherits any modifications made to the student object, only the programmer responsible for the student object needs to handle those changes. 

Inheritance also allows you to restrict access to certain traits and actions. As we all know, access specifiers are used to designate which sections of the programme have access to certain properties and actions. Members of a class that are available to other members of the class, other classes, and other elements of the programme are defined by the public access specifier.

The private access specifier is used to specify members that can only be accessed by other members of the same class. Other classes and portions of the curriculum do not have access to them. The protected access specifier describes the characteristics and actions that are available to members of the class and inherited classes. Limiting access to properties and actions serves to protect the object's integrity by limiting how other classes and areas of the application interact with it.

Let's see with a practical example of inheritance and have a detailed discussion over class hierarchy in c++ and java.

Also see,  Swap Function in Java

Class Hierarchy

A parent-child connection is a term used to describe the hierarchical relationship between classes. The child inherits all of the parent's attributes and behaviours, and it utilises the parent's access specifier to govern how those inherited things are exposed to other classes or functions in a parent-child connection.

The parent is referred to as a base class in C++, whereas the child is referred to as a derived class. The superclass in Java is the parent, while the subclass is the child.

Types of classes

Inheritance may be implemented in a software in three ways. There are three types of inheritance: 

1. simple inheritance 
2. multiple inheritance, and 
3. level inheritance.

Each uses somewhat different ways to allow a class to access the characteristics and actions of another class.

Simple Inheritance

When there is only one parent-child connection, simple inheritance occurs. In other words, just one child inherits from each father.

C++ Program 

#include <iostream>
#include <string.h>

using namespace std;

class Student
{
protected:
   int m_Graduation, m_ID;
   char m_First[16], m_Last[16];

public:
   virtual void Display()
   {
       cout << "ID: " << m_ID << endl;
       cout << "First: " << m_First << endl;
       cout << "Last: " << m_Last << endl;
       cout << "Graduation: " << m_Graduation << endl;
   }
  
   void Write(int ID, char First[], char Last[], int Graduation)
   {
       m_ID = ID;
       strcpy(m_First, First);
       strcpy(m_Last, Last);
       m_Graduation = Graduation;
   }

   Student()
   {
       m_ID = m_Graduation = 0;
       m_First[0] = m_Last[0] = '\0';
   }
};

class GradStudent : public Student
{
protected:
   int m_UndergradGraduation;
   char m_UndergradSchool[64];
   char m_Major[64];

public:
   GradStudent()
   {
       m_UndergradGraduation = 0;
       m_UndergradSchool[0] = m_Major[0] = '\0';
   }
  
   virtual void Write(int ID, char First[], char Last[], int Graduation, char Major[], char UndergradSchool[], int UndergradGraduation)
   {
       Student::Write(ID, First, Last, Graduation);
       strcpy(m_Major, Major);
       strcpy(m_UndergradSchool, UndergradSchool);
       m_UndergradGraduation = UndergradGraduation;
   }
  
   virtual void Display()
   {
       Student::Display();
       cout << "Major: " << m_Major << endl;
       cout << "Undergrad school: " << m_UndergradSchool << endl;
       cout << "Undergrad graduation: " << m_UndergradGraduation << endl;
   }
};

int main()
{
   Student student;
   GradStudent graduate;
  
       student.Write(100, "Aman", "Thakur", 2023);
       graduate.Write(101, "Aman", "Chowrasia", 2022, "Computer Science", "IIT", 2018);
      
       student.Display();
       graduate.Display();
  
   return 0;
}

Output

Java Program 

class Student {
   protected int nID, nGraduation;
   protected String studentFirst, studentLast;

   public Student() {
       nID = 0;
       nGraduation = 0;
       studentFirst = new String();
       studentLast = new String();
   }

   public void Display() {
       System.out.println("ID: " + nID);
       System.out.println("First: " + studentFirst);
       System.out.println("Last: " + studentLast);
       System.out.println("Graduation: " + nGraduation);
   }

   public void Write(int nID, String studentFirst, String studentLast, int nGraduation) {
       this.nID = nID;
       this.studentFirst = studentFirst;
       this.studentLast = studentLast;
       this.nGraduation = nGraduation;
   }
}

class GradStudent extends Student {
   String studentMajor, studentUndergradSchool;
   int nUndergradGraduation;

   public GradStudent() {
       studentMajor = "";
       studentUndergradSchool = "";
       nUndergradGraduation = 0;
   }

   public void Display() {
       super.Display();
       System.out.println("Major: " + studentMajor);
       System.out.println("Undergrad Graduation year: " +
               nUndergradGraduation);
       System.out.println("Undergrad School: " + studentUndergradSchool);
   }

   public void Write(int ID, String First, String Last, int Graduation, String Major, String UndergradSchool,
           int UndergradGraduation) {
       super.Write(ID, First, Last, Graduation);
       studentUndergradSchool = UndergradSchool;
       studentMajor = Major;
       nUndergradGraduation = UndergradGraduation;
   }
}

public class StudentApp {
   public static void main(String[] args) {
       Student student = new Student();
       GradStudent graduate = new GradStudent();
       student.Write(100, "Aman", "Thakur", 2023);
       graduate.Write(101, "Aman", "Chowrasia", 2022, "Computer Science", "IIT", 2018);
       student.Display();
       graduate.Display();
   }

   public static void Display(Student student) {
       student.Display();
   }

   public static void Display(GradStudent graduate) {
       graduate.Display();
   }
}

Output

Multiple Inheritance

When there are many parents and a child in a relationship, multiple inheritance occurs. In other words, the child receives inheritance from both parents.

C++ Program

#include <iostream>
#include <string.h>

using namespace std;

class Person
{
protected:
  int m_ID;
  char m_First[16], m_Last[16];

public:
  Person()
  {
     this->m_ID = 0;
     this->m_First[0] = this->m_Last[0] = '\0';
  }

  virtual void Display()
  {
     cout << "ID: " << m_ID << endl;
     cout << "First: " << m_First << endl;
     cout << "Last: " << m_Last << endl;
  }

  void Write(int ID, char First[], char Last[])
  {
     this->m_ID = ID;
     strcpy(this->m_First, First);
     strcpy(this->m_Last, Last);
  }
};

class Worker
{
protected:
  int m_Income;

public:
  Worker()
  {
     this->m_Income = 0;
  }
  void Write(int Income)
  {
     m_Income = Income;
  }
  void Display()
  {
     cout << "Income: " << m_Income << endl;
  }
};

class Instructor : public Person, public Worker
{
protected:
  bool m_Tenured;

public:
  Instructor()
  {
     this->m_Tenured = false;
  }
  void Write(int ID, char First[], char Last[], bool Tenured,
             int Salary)
  {
     Person::Write(ID, First, Last);
     Worker::Write(Salary);
     m_Tenured = Tenured;
  }
  void Display()
  {
     Person::Display();
     Worker::Display();
     cout << "Tenured: " << (m_Tenured ? "Yes" : "No") << endl;
  }
};

int main()
{
  Instructor instructor;
  instructor.Write(100, "Aman", "Thakur", true, 15000);
  instructor.Display();
  return 0;
}

Output

Java Program

Java does not allow multiple inheritance. As a result, if you want a class to inherit from two or more other classes, you'll need to employ level inheritance. Remember that the "is a" test must be passed by each class. Level inheritance should not be utilised with any class that fails this condition.

Instead, Java provides interfaces, which might behave or appear to be Multiple Inheritance in Java in various respects. An interface, on the other hand, is best compared to a totally abstract class. That is, it declares the names of member functions but does not give any reusable code from which inheritance may be used. If we use a Java class to implement an interface, we must write all of the necessary code for those functions ourselves.As a result, interfaces are not considered to be part of inheritance.

Interfaces should be thought of as a series of promises. If a class implements an interface (and so has all of the code required to do so), other objects can interact or cooperate with the class through the interface.

You can also read about the Multiple Inheritance in Java, Duck Number in Java

Level inheritance

When a child inherits from a parent and subsequently becomes a parent to a child, this is known as level inheritance.

C++ Program

#include <iostream>
#include <string.h>

using namespace std;

class Person
{
protected:
   int m_ID;
   char m_First[16], m_Last[16];

public:
   Person()
   {
       m_ID = 0;
       m_First[0] = m_Last[0] = '\0';
   }
   virtual void Display()

   {
       cout << "ID: " << m_ID << endl;
       cout << "First: " << m_First << endl;
       cout << "Last: " << m_Last << endl;
   }
   void Write(int ID, char First[], char Last[])
   {
       m_ID = ID;
       strcpy(m_First, First);
       strcpy(m_Last, Last);
   }
};

class Student : public Person
{
protected:
   int m_Graduation;

public:
   virtual void Display()
   {
       Person::Display();
       cout << "Graduation: " << m_Graduation << endl;
   }

   void Write(int ID, char First[], char Last[], int Graduation)
   {
       Person::Write(ID, First, Last);
       m_Graduation = Graduation;
   }

   Student()
   {

       m_Graduation = 0;
   }
};

class GradStudent : public Student
{
protected:
   int m_UndergradGraduation;
   char m_UndergradSchool[64];
   char m_Major[64];

public:
   GradStudent()
   {
       m_UndergradGraduation = 0;
       m_UndergradSchool[0] = m_Major[0] = '\0';
   }

   virtual void Write(int ID, char First[], char Last[], int Graduation,
                      char Major[], char UndergradSchool[], int UndergradGraduation)
   {
       Student::Write(ID, First, Last, Graduation);
       strcpy(m_Major, Major);
       strcpy(m_UndergradSchool, UndergradSchool);
       m_UndergradGraduation = UndergradGraduation;
   }

   virtual void Display()
   {
       Student::Display();
       cout << "Major: " << m_Major << endl;
       cout << "Undergrad school: " << m_UndergradSchool << endl;
       cout << "Undergrad graduation: " << m_UndergradGraduation << endl;
   }
};

int main()
{
   Student student;
   GradStudent graduate;
  
       student.Write(100, "Aman", "Thakur", 2023);
       graduate.Write(101, "Aman", "Chowrasia", 2022, "Computer Science", "IIT", 2018);
      
       student.Display();
       graduate.Display();
  
   return 0;
}

Output

Java Program

class Person
{
   protected int nID;
   protected String studentFirst, studentLast;
  
   public Person()
   {
       this.nID = 0;
       this.studentFirst = "";
       this.studentLast = "";
   }
  
   public void Display()
   {
       System.out.println("ID: " + nID);
       System.out.println("First: " + studentFirst);
       System.out.println("Last: " + studentLast);
   }

   public void Write( int ID, String First, String Last )
   {
       nID = ID;
       this.studentFirst = First;
       this.studentLast = Last;
   }
}

class Student extends Person
{
   protected int nGraduation;
  
   public Student()
   {
       this.nGraduation = 0;
   }

   public void Display() 
   {
       super.Display();
       System.out.println("Graduation: " + nGraduation);
   }

   public void Write( int ID, String First, String Last, int Graduation )
   {
       super.Write(ID, First, Last);
       this.nGraduation = Graduation;
   }
}

class GradStudent extends Student
{
   String studentMajor, studentUndergradSchool;
   int nUndergradGraduation;
  
   public GradStudent()
   {
       this.studentMajor = "";
       this.studentUndergradSchool = "";
       this.nUndergradGraduation = 0;
   }

   public void Display()
   {
       super.Display();
       System.out.println("Major: " + studentMajor );
       System.out.println("Undergrad Graduation year: " +
       nUndergradGraduation);
       System.out.println("Undergrad School: " + studentUndergradSchool );
   }

   public void Write( int ID, String First, String Last, int Graduation,String Major, String UndergradSchool, int UndergradGraduation )
   {
       super.Write( ID, First, Last, Graduation);
       this.studentUndergradSchool = UndergradSchool;
       this.studentMajor = Major;
       this.nUndergradGraduation = UndergradGraduation;
   }
}

public class StudentApp
{
   public static void main(String[] args)
   {
       Student student = new Student();
       GradStudent graduate = new GradStudent();
      
       student.Write(100, "Aman", "Thakur", 2023);
       graduate.Write(101, "Aman", "Chowrasia", 2022, "Computer Science", "IIT", 2018);
      
       student.Display();
       graduate.Display();
   }

   public static void Display(Student student)
   {
       student.Display();
   }

   public static void Display(GradStudent graduate)
   {
       graduate.Display();
   }

}

Output

Try Online Java Compiler.

Know about Single Inheritance in Java in detail.

Get the tech career you deserve, faster!
Connect with our expert counsellors to understand how to hack your way to success
User rating 4.7/5
1:1 doubt support
95% placement record
Akash Pal
Senior Software Engineer
326% Hike After Job Bootcamp
Himanshu Gusain
Programmer Analyst
32 LPA After Job Bootcamp
After Job
Bootcamp

Frequently Asked Questions

  1. Does C++ support all types of inheritance does Java support all?
    Multiple inheritance is supported by C++, Common Lisp, and a few other languages, but not by Java. To prevent the uncertainty that multiple inheritance causes, Java does not allow it. The diamond problem, which happens in multiple inheritance, is an example of such a problem.
     
  2. How multiple inheritance is used in java?
    Several inheritance can only be achieved by implementing multiple interfaces in a class. One class can implement two or more interfaces in Java. This also eliminates any misunderstanding because all interface functions are implemented in classes.
     
  3.  What is the difference between protected and private access specifiers in inheritance?
    Both are inheritable, but the derived class does not have access to protected. The distinction between protected and private access specifiers in inheritance is that protected members are inheritable and also available in derived classes.
     
  4.  What is the disadvantage of inheritance in Java?
    The inheritance connection is a strongly connected relationship in which the parent and child have a strong tie. If we update the parent class's code, it will effect all of the child classes that inherit the parent's code.

Conclusion

If you have reached till here that means you really enjoyed reading this article. This article covers the implemable difference between java and c++ and various types of inheritance and a detailed explanation of the subject.

We hope that this blog has helped you enhance your knowledge regarding Inheritance in Java and Inheritance in C++ .

Recommended Readings:

 

Do upvote our blog to help other ninjas grow, and head over to our practice platform Coding Ninjas Studio to practice top problems, attempt mock tests, read interview experiences, and much more.!


Happy Learning!

Previous article
What is the Diamond Problem in Java?
Next article
Hierarchical Inheritance in Java
Live masterclass