![\"Java](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/inheritance-in-java.jpg\")
<\/a><\/p>\nThe above figure illustrates:<\/p>\n
- \n
- Automobiles<\/strong> and Pulled Vehicles<\/strong> are subclasses of Vehicles<\/strong>.<\/li>\n
- Vehicles<\/strong> are the base class or superclass of Automobiles<\/strong> and pulled Vehicles<\/strong>.<\/li>\n
- Car<\/strong> and Bus<\/strong> are sub-classes or derived classes of Automobiles<\/strong>.<\/li>\n
- Automobiles<\/strong> are the base class or superclass of Car<\/strong> and Bus.<\/strong><\/li>\n<\/ul>\n
Why Java Inheritance?<\/h3>\n
There are several reasons why inheritance was introduced into Object-oriented languages. We will discuss some major reasons behind the introduction of inheritance.<\/p>\n
- \n
- The capability to express inheritance relationships ensures the closeness with the real-world models.<\/strong><\/li>\n
- Another reason is the idea of reusability.<\/strong> One can derive a new class (sub-class) from an existing class and add new features to it without modifying its parent class. There is no need to rewrite the parent class in order to inherit it.<\/li>\n
- One reason is the transitive nature.<\/strong> If class A<\/strong> inherits properties from another class B<\/strong>, then all subclasses of A<\/strong> will automatically inherit properties from B<\/strong>. This property is called the transitive nature of inheritance.<\/li>\n<\/ul>\n
Note:<\/strong> A subclass defines only those features that are unique to it. <\/em><\/p>\n
For example, the class Student<\/strong> inherits from the class Person<\/strong>. Then although Student is a person, the reverse is not true. A Person need not be a Student. The class Student has properties that it does not share with class Person.<\/p>\n
For instance, the Student<\/strong> has a marks-percentage, but the Person<\/strong> does not have.<\/p>\n
Important Terms in Java Inheritance<\/h3>\n
1. Class:<\/strong> Class is a user-defined datatype in Java that is basically a group of objects. It is a blueprint or template from which we create objects.<\/p>\n
2. Super Class:<\/strong> The class whose features and functionalities are being inherited or used is known as the superclass or a base class or a parent class.<\/p>\n
3. Sub Class:<\/strong> The class that inherits the properties and features from another class is known as a subclass or a derived class or extended class or child class. The subclass can add its own features and functions in addition to the fields and methods of its superclass or the parent class.<\/p>\n
4. The extends keyword:<\/strong> The keyword extends is used by child class while inheriting the parent class.<\/p>\n
5. The super keyword:<\/strong> The super keyword is similar to this keyword. The following are some cases where we use super keyword :<\/p>\n
- \n
- There are some situations where the members of the superclass and the subclass have the same names, then the super keyword is used to differentiate the members of the superclass from the members of the subclass.<\/li>\n
- To invoke the superclass constructor from the subclass.<\/li>\n<\/ul>\n
Syntax of using Inheritance in Java:<\/strong><\/p>\n
We already know that to inherit a class, we use the extends keyword. The syntax of using inheritance in Java is:<\/p>\n
class BaseClass\n{\n \t\/\/methods and fields\n}\nclass DerivedClass extends BaseClass\n{\n \t\/\/methods and fields\n}<\/pre>\nCode to explain Java Inheritance:<\/strong><\/p>\n
package com.techvidvan.inheritance;\n\/\/Base class\nclass Person\n{\n String name = \"John\";\n int age =17;\n String city = \"Delhi\";\n public void show()\n {\n System.out.println(\"Student inheriting properties from Person:\\n\");\n }\n}\n\/\/child class\nclass Student extends Person\n{\n \/\/ defining additional properties to child class\n int marks = 78;\n String tutorial = \"TechVidvan Tutorial of Java\";\n\n public static void main(String args[])\n {\n Student obj = new Student();\n obj.show();\n\n System.out.println(\"Name of the student is: \" + obj.name);\n System.out.println(\"Age of the student is: \" + obj.age);\n System.out.println(\"Student lives in: \" + obj.city);\n System.out.println(\"Student learns from: \" + obj.tutorial);\n System.out.println(\"Marks obtained by the student is: \" + obj.marks);\n }\n}<\/pre>\nOutput:<\/strong><\/p>\n
Student inheriting properties from Person:
\nName of the student is: John
\nAge of the student is: 17
\nStudent lives in: Delhi
\nStudent learns from: TechVidvan Tutorial of Java
\nMarks obtained by the student is: 78<\/div>\nFrom the above program, we can say that Student IS-A Person.<\/strong> This means that a derived class has an IS-A<\/strong> relationship with the base class. This inheritance is called IS-A<\/strong> relationship between the child and parent class.<\/p>\n
In the above code, when an object of Student class is created, a copy of all the methods and fields of the superclass acquire memory in this object. Therefore, we are able to access the members of the superclass by using the object of the subclass.<\/p>\n
Please note that during inheritance, we create the object of only the subclass, not the superclass.<\/p>\n
Types of Java Inheritance<\/h3>\n
![\"Java](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/types-of-java-inheritance.jpg\")
<\/a><\/p>\nFrom the above diagram, we can see that there are five types of inheritance in Java. They are classified on the basis of the number of super and subclasses.<\/p>\n
There is an exception that \u2018multiple inheritance\u2019 is not directly supported by classes in Java. Rather we use interfaces to implement multiple inheritances in Java.<\/p>\n
Now, we will discuss each type of inheritance with examples and programs.<\/p>\n
1. Single Inheritance in Java<\/h4>\n
In single inheritance, there is a single child class that inherits properties from one parent class.<\/p>\n
In the following diagram, class A is a base class that is derived from class B. It is also known as single-level inheritance.<\/p>\n
![\"single](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/single-inheritance-in-java.jpg\")
<\/a><\/p>\nSyntax of single Inheritance:<\/strong><\/p>\n
class A\n{\n \/\/methods and fields\n}\nClass B extends A\n{\n \/\/methods and fields<\/pre>\nCode to illustrate Single Inheritance:<\/strong><\/p>\n
package com.techvidvan.inheritance;\n\/\/Base class\nclass Person\n{\n String name=\"John\";\n public void show()\n {\n System.out.println(\"Student inheriting properties from Person\");\n }\n}\n\/\/child class\nclass Student extends Person\n{\n \/\/ defining additional properties to child class\n String course = \"Techvidvan's Java Course\";\n public void show1()\n {\n System.out.println(\"I am a Student who belongs to Person class\");\n }\n public static void main(String args[])\n {\n Student obj = new Student();\n obj.show();\n obj.show1();\n System.out.println(\"Name of student: \" +obj.name);\n System.out.println(\"Course opted by the student: \" +obj.course);\n }\n}<\/pre>\nOutput:<\/strong><\/p>\n
Student inheriting properties from Person
\nI am a Student who belongs to Person class
\nName of student: John
\nCourse opted by the student: Techvidvan’s Java Course<\/div>\n2. Multilevel Inheritance in Java<\/h4>\n
In this type of inheritance, the child or derived class inherits the features of the superclass and simultaneously this child class acts as a superclass for another derived class.<\/p>\n
In the following diagram, class A is a base class that is derived from class B, which in turn, acts as a base class for a derived class C.<\/p>\n
![\"multilevel](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/multilevel-inheritance-in-java.jpg\")
<\/a><\/p>\nCode to illustrate Multilevel Inheritance:<\/strong><\/p>\n
package com.techvidvan.inheritance;\n\/\/Base class\nclass Person\n{\n public void show()\n {\n System.out.println(\"Student inheriting properties from Person\");\n }\n}\nclass Student extends Person\n{\n public void show1()\n {\n System.out.println(\"I am a Student who belongs to Person class\");\n }\n}\n\/\/child class\nclass EngineeringStudent extends Student\n{\n \/\/ defining additional properties to the child class\n public void show2()\n {\n System.out.println(\"Engineering Student inheriting properties from Student\");\n }\n}\npublic class MultilevelDemo\n{\n public static void main(String args[])\n {\n EngineeringStudent obj = new EngineeringStudent();\n obj.show();\n obj.show1();\n obj.show2();\n }\n}<\/pre>\nOutput:<\/strong><\/p>\n
Student inheriting properties from Person
\nI am a Student who belongs to Person class
\nEngineering Student inheriting properties from Student<\/div>\n3. Hierarchical Inheritance in Java<\/h4>\n
In Hierarchical Inheritance, one class acts as a superclass (base class) for more than one subclass. More than one subclass can inherit the features of a base class.<\/p>\n
In the following diagram, class A is a base class for the derived classes B, C, and D.<\/p>\n
![\"Hierarchial](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/hierarchial-inheritance-in-java.jpg\")
<\/a><\/p>\nCode to illustrate Hierarchical Inheritance:<\/strong><\/p>\n
package com.techvidvan.inheritance;\n\n\/\/Base class\nclass Person\n{\n public void show()\n {\n System.out.println(\"I am a Person\");\n }\n}\n\n\/\/child class1\nclass Student extends Person\n{\n public void show1()\n {\n System.out.println(\"I am a Student who is Person \");\n }\n}\n\n\/\/child class2\nclass Teacher extends Person\n{\n \/\/ defining additional properties to the child class\n\n public void show2()\n {\n System.out.println(\"I am a Teacher who is a Person\");\n }\n}\n\/\/child class3\nclass Doctor extends Person\n{\n \/\/ defining additional properties to the child class\n\n public void show3()\n {\n System.out.println(\"I am a Doctor who is a Person\");\n }\n}\n\npublic class HierarchicalInheritance\n{\n public static void main(String args[])\n {\n Teacher teacher = new Teacher();\n Student student = new Student();\n Doctor doctor = new Doctor();\n student.show();\n student.show1();\n teacher.show2();\n doctor.show3();\n }\n}<\/pre>\nOutput:<\/strong><\/p>\n
I am a Person
\nI am a Student who is Person
\nI am a Teacher who is a Person
\nI am a Doctor who is a Person<\/div>\n4. Multiple Inheritance in Java<\/h4>\n
In Multiple Inheritance, one child or subclass class can have more than one base class or superclass and inherit features from every parent class which it inherits.<\/p>\n
We have already discussed that Java does not support multiple inheritances with classes. We can achieve multiple inheritances only with the help of Interfaces.<\/p>\n
In the following diagram, Class C inherits from interfaces A and B.<\/p>\n
![\"Multiple](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/multiple-inheritance-in-java.jpg\")
<\/a><\/p>\nCode to illustrate Multiple Inheritance:<\/strong><\/p>\n
package com.techvidvan.inheritance;\n\n\/\/base interface1\ninterface Moveable\n{\n public void run();\n}\n\n\/\/base interface2\ninterface Speakable\n{\n public void speak();\n}\n\n\/\/child interface inheriting two base interfaces\ninterface Ability extends Moveable, Speakable\n{\n public void show();\n}\n\nclass Person implements Ability\n{\n @Override\n public void run()\n {\n System.out.println(\"I can run !!\");\n }\n @Override\n public void speak()\n {\n System.out.println(\"I can speak !!\");\n }\n @Override\n public void show() \n {\n System.out.println(\"I am a person, I can speak and run !!\");\n }\n}\n\npublic class MultipleInheritance\n{\n public static void main(String[] args)\n {\n Person obj = new Person();\n obj.run();\n obj.speak();\n obj.show();\n }\n}<\/pre>\nOutput:<\/strong><\/p>\n
I can run !!
\nI can speak !!
\nI am a person, I can speak and run !!<\/div>\n5. Hybrid Inheritance in Java<\/h4>\n
It is a combination of two or more types of inheritance. The hybrid inheritance is also not possible with classes because Java doesn\u2019t support multiple inheritance with classes. We can achieve hybrid inheritance only through Interfaces.<\/p>\n
In the following diagram, class A is the base class for subclasses B and C. And, class D inherits both the classes B and C.<\/p>\n
![\"Hybrid](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/hybrid-inheritance-in-java.jpg\")
<\/a><\/p>\nCode to illustrate hybrid Inheritance:<\/strong><\/p>\n
package com.techvidvan.inheritance;\n\/\/base class 1\nclass Ability\n{\n public void show()\n {\n System.out.println(\"I am a person, I can speak and run !!\");\n }\n}\n\n\/\/child interface 1\ninterface Moveable\n{\n public void run();\n}\n\n\/\/child interface2\ninterface Speakable\n{\n public void speak();\n}\n\n\/\/child class inheriting two base interfaces\nclass Person extends Ability implements Moveable, Speakable\n{\n @Override\n public void run()\n {\n System.out.println(\"I can run !!\");\n }\n @Override\n public void speak()\n {\n System.out.println(\"I can speak !!\");\n }\n}\n\npublic class HybridInheritance\n{\n public static void main(String[] args)\n {\n Person obj = new Person();\n obj.run();\n obj.speak();\n obj.show();\n }\n}<\/pre>\nOutput:<\/strong><\/p>\n
I can run !!
\nI can speak !!
\nI am a person, I can speak and run !!<\/div>\nInheritance in OOP with Real-time Example<\/h3>\n
Consider an application Polygon that represents different types of Shapes.<\/p>\n
We are supposed to create two different types of Polygons, one will be Rectangle and the other will be Triangle.<\/p>\n
Let’s compare and study the two different approaches of coding with a structured and object-oriented programming perspective.<\/p>\n
Structural approach:<\/strong><\/p>\n
Using a structured programming approach, we will create two functions:<\/p>\n
- \n
- One to get the Number of sides of a polygon.<\/li>\n
- And the other to calculate the area.<\/li>\n<\/ul>\n
The working of these functions remains the same across two different shapes.<\/p>\n
![\"Structural](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/strucutral-approach.jpg\")
<\/a><\/p>\nOOP’s approach:<\/strong><\/p>\n
Using the OOPs programming approach, we would create two different classes.<\/p>\n
- \n
- Each having implementation of thegetNumberOfSides() and getArea() functions.<\/li>\n
- This will reduce extra work.<\/li>\n<\/ul>\n
![\"OOP's](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/OOPs-Approach.jpg\")
<\/a><\/p>\nChange Request in Software<\/h4>\n
Suppose there is a change in the functionality of the software. You are supposed to add the functionality of finding the area of a Square.<\/p>\n
Let\u2019s see how to deal with this problem with both approaches.<\/p>\n
Structural approach:<\/strong><\/p>\n
If we want to add a new feature using a functional or traditional methodology, we will need to modify the getArea() function which is already tested and baselined. If we add new functionality of finding the area of a Square then our code will look like:<\/p>\n
![\"Structural](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/structural-approach-1.jpg\")
<\/a><\/p>\nOOP’s approach:<\/strong><\/p>\n
Using the Object-Oriented approach, you just require to add a new class Square which will have the unique functionality of finding the area of Square. There is no need to change the piece of code that is already tested by using this approach.<\/p>\n
![\"The](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/oop-approach.jpg\")
<\/a><\/p>\nAnother Change Request<\/h4>\n
Suppose if there are some more changes required in the software. For example, if you want to add a Shape Parallelogram with its own unique requirements.<\/p>\n
Structural approach:<\/strong><\/p>\n
If we want to add the Parallelogram Shape in the existing class using the structural approach, then we will definitely need to make changes in the existing code.<\/p>\n
OOP’s approach:<\/strong><\/p>\n
If we want to add another shape in the existing class using the object-oriented approach, we will just need to create a new class Parallelogram with its unique methods. The diagram below illustrates the same –<\/p>\n
![\"OOP's](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/OOPs-Approach-1.jpg\")
<\/a><\/p>\nSo, even though at the initial stage, the structural programming was appearing to be an easy approach, but as the complexity of the code increases and there are more changes in the requirements then this approach fails.<\/p>\n
Eventually, the Object-Oriented approach wins in the long term.<\/p>\n
But you might be thinking that across all the classes, we have to write a repeated piece of code for each class.<\/p>\n
To overcome this problem of repetition, we can create a parent class called \u201cShape\u201d and implement the same function of getNumberOfSides and getArea. Then we will create the child classes that will inherit this parent class Shape.<\/p>\n
So that they will have access to getNumberOfSides and getArea functions in the Shape class.<\/p>\n
There is no need to declare these functions in each class. This concept is called Inheritance in java.<\/p>\n
- Another reason is the idea of reusability.<\/strong> One can derive a new class (sub-class) from an existing class and add new features to it without modifying its parent class. There is no need to rewrite the parent class in order to inherit it.<\/li>\n
- Vehicles<\/strong> are the base class or superclass of Automobiles<\/strong> and pulled Vehicles<\/strong>.<\/li>\n