Inheritance In Java

What is Inheritance?

• If the relationship between two classes is "IS A" and "IS A TYPE OF"then that relationship is termed Inheritance. Example:- Dog IS-A Animal. Here, Dog and Animal are two classes.

• Inheritance is one of the major features of OO concepts.

• extends keyword is used to establish Inheritance in code.

Define Inheritance

Inheritance is a process in which one object or child class can acquire the properties and behavior of the parent object or parent class. Using inheritance new classes can be built on already existing classes so that the new class can reuse methods and fields present in the parent class.

Inheritance represents an IS-A relationship, also known as a parent-child relationship.

The parent class is also called the super-class. The child class is also known as the sub-class.

Real-Time Example of Inheritance

A son will inherit all the features and the behavior of the father and he will have his own special features and behavior as well. This is what inheritance is in general.

Benefits of Inheritance

1. Code reusability - Attributes and methods defined in a superclass are automatically inherited by all its sub-classes and reused.

2. Easy maintenance - If any changes are to be incorporated, it can be done in the superclass, which in turn gets reflected all the sub-classes, making maintenance easy.

Example

1. Without Inheritance

public class Employee{ 
private int empld; 
private String name;

public Employee()
}                          
System.out.println("In Employee Constructor");
//Assume Getters and setters for all attributes
}
}
/ ************************************* /
public class PermanentEmployee
private int empld; 
private String name; 
private int basicPay;

public PermanentEmployee()
System.out.println("In PermanentEmployee constructor ");
}
// Assume Getters and setters for all attributes
}
}

2. With Inheritance

A Permanent Employee is an or is a type of Employee. So, there is an IS-A relationship between the Employee class and PermanentEmployee class.

The parent class constructor gets executed first.

// parent class
public class Employee{
private int empld;
private String name;

public Employee() { //constructor
System.out.println("In Employee
Constructor");
}

// child class
public class PermanentEmployee extends Employee {
private int basicPay;

public PermanentEmployee() 
//constructor
System.out.println("In PermanentEmployee constructor");
}
}

// main class
public class EmployeeMain{
public static void main(String a[]) {
PermanentEmployee perEmpObj = new PermanentEmployee();
}
}
Output:
In Employee Constructor
In PermanentEmployee Constructor

Guidelines

1. Private members of the superclass are not inherited by the subclass; instead, they can only be indirectly accessed using public methods.

2. Members with default access specifiers in a superclass cannot be inherited by subclasses in other packages. They can be accessed directly using their names in subclasses within the same package as the superclass.

3. The protected modifier specifies that the member can only be accessed within its own package and, in addition, by a subclass of its class in another package.

4. Constructors are not members of a class. So they are not inherited by a subclass, but the constructor of the superclass can be invoked from the subclass.

Types of Inheritance In Java

1. Single level Inheritance

2. Multilevel Inheritance

3. Hierarchical Inheritance

Multiple Inheritance is not supported In java.

Method Overriding

A subclass can have a method with the same name, argument list, and return type (except co-variant type) as declared in the parent class, but with a different implementation. This concept is called Method overriding.

Rules for Method overriding

1. The method name should be the same as in the parent class.

2. The method argument list should be the same as in the parent class.

3. The method should have the same return type (or its sub-type).

4. The subclass overridden method cannot have weaker access than the superclass method. Example: If the parent class method is declared as public, then the overridden method in the subclass cannot be private or protected, or default.

5. When the overridden method is invoked using a sub-class object, it will override the method in the parent class and execute the method in the child class. Hence the concept of Method overriding.

Example For Method Overriding

// Parent class
public class Employee{ 
protected int empld; 
protected String name; 

public Employee() {           //constructor
System.out.println("In Employee Constructor");
}

//Assume you have written getters and setters for empld and name
public float calculateSalary() {
System.out.println("In Super class calculateSalary Method"); 
return 1;
}
}

// Child class
public class PermanentEmployee extends Employee {
private int basicPay;

public PermanentEmployee() //constructor
System.out.println("In PermanentEmployee constructor");
}

// Assume you have written getters and setters for basicPay 
public float calculateSalary()  // Overriding the method in super class
float da = basicPay* 0.10f;
float pf = basicPay* 0.12f;
float salary = basicPay+da - pf;
return salary;
}
}

 //Main class
public class EmployeeUtility (
public static void main(String a[]) {

Employee empObj = new Employee();
 empObj.setEmpld(101); 
empObj.setName("Rohith"); 
empObj.calcuateSalary();

PermanentEmployee perEmpObj = new PermanentEmployee(); 
perEmpObj.setEmpld(102); 
perEmpObj.setName("Tom"); 
perEmpObj.setBasicPay(35000); 
System.out.println("Salary is "+ perEmpObj.calculateSalary());
} }
Output:
In Employee Constructor 
In Super class calculateSalary Method

In Employee Constructor 
In PermanentEmployee constructor 
Salary is 34300.0

---

created by Vaishnavi Chaurasia @TechInfinity