Abstract Classes: Runtime Polymorphism

Before reading this post, I recommend you to go through Runtime Polymorphism since this post is an extension of the same.

Consider an organization where an Employee can be a Regular Employee or a Consultant. After all, an employee cannot be just an employee. An employee is under one of these categories. To simulate these types of cases in OOP, we make use of abstract classes in Java.

An abstract method (pure virtual function in C++) doesn’t contain a body. An abstract method must be overridden in subclass. Otherwise, the subclass will become abstract.

A class having one or more abstract functions can be declared as an abstract class. We cannot create an object for an abstract class. However, an object reference for an abstract class can be created. Now you may doubt the use of creating a class without an object. For example, in the above example, an object of the Employee class should not be created since an employee cannot just be an employee. Such types of classes should be defined as abstract classes. Now if we allow the objects to be created for an Employee class, it might lead to extra memory usage and also might defeat the very purpose of runtime polymorphism. But we can create an object reference of Employee and point it to an object of its subclass. This is where runtimepolymorphism again comes into picture. In the previous post, you must have already read the golden rule of Runtime Polymorphism: “An object reference of a super class can always point to an object of a subclass.” Instead of the super class object reference pointing to an object of subclass, we now make the abstract class object reference pointing to an object of a subclass.

The implementation for Employee Class is given below.

public abstract class Employee { private int emp_id; private String emp_name; public Employee(int emp_id, String emp_name) { this.emp_id = emp_id; this.emp_name = emp_name; } public int getEmp_id() { return emp_id; } public void setEmp_id(int emp_id) { this.emp_id = emp_id; } public String getEmp_name() { return emp_name; } public void setEmp_name(String emp_name) { this.emp_name = emp_name; } // Abstract Function since implementation differs protected abstract int getPay(); }

The implementation for RegularEmployee class is given below.

public class RegularEmployee extends Employee { private int salary; public RegularEmployee(int emp_id, String emp_name,int salary) { super(emp_id, emp_name); this.salary=salary; } @Override protected int getPay() { return salary; } }

The implementation for Consultant class is given below.

public class Consultant extends Employee { private int no_hours,hour_rate; public Consultant(int emp_id, String emp_name,int no_hours,int hour_rate) { super(emp_id, emp_name); this.no_hours=no_hours; this.hour_rate=hour_rate; } @Override protected int getPay() { return no_hours*hour_rate; } }

You can observe that the abstract method in the superclass is overridden in both the above subclasses. Now we will see how runtime polymorphism can be applied using abstract classes.

Employee emp; // Objects for abstract classes not created // Object Reference emp created emp=new RegularEmployee(1,"Sai",2000); // Object ref. of super class refers to an object of subclass System.out.println("Regular Employee's Pay:"+emp.getPay()); emp=new Consultant(2,"Ravi",100,20); // Object ref. of super class refers to an object of subclass System.out.println("Consultant's Pay:"+emp.getPay());

A class can be declared as an abstract class even though it doesn’t contain any abstract methods. This can be used in situations where there are no abstract functions to be overridden in the subclasses, but at the same time, the abstract class should not have an object.

An abstract class can contain other non-abstract members such as methods and instance variables.

Related Posts:

Runtime Polymorphism
Interfaces in Java
How Interfaces are internally used in Java