Introduction to Virtual Function in Java
Being an object-oriented programming language, java supports features like inheritance, polymorphism, upcasting, etc. Therefore, OOPs in Java deals with objects, classes, and functions. A virtual function is one of the member function that facilitates run time polymorphism in Java. In this article, we will discuss the virtual function in Java.
Definition: A virtual function is not any special function, but it is a member function that facilitates the method overriding mechanism. That means, in OOPs, a virtual function of the parent class is a function that can be overridden by a child class that has the same type but with different functionality.
Syntax: For Virtual Function in Java, you should follow the basic syntax of java with annotations. To implement the overriding mechanism for the virtual function, @Override annotation may be used here to specifically point out which virtual function we want to override, although it is not mandatory.
How Virtual Function Works in Java?
Now let us see how virtual function works. When we call an overridden method of child class through its parent type reference, then the type or reference of the object indicates which method will be invoked. The conclusion of this decision occurs during runtime after the compilation. So, the virtual function’s functionality is overridden by the inherited child class of the same type.
Some Points Regarding Virtual Function:
- Functions of child and parent class must have the same name and have the same parameter.
- IS-A relationship is mandatory (inheritance).
- A virtual function cannot be private as we cannot override the parent class’s private methods.
- A virtual function cannot be stated as Final, as we cannot override Final methods.
- A virtual function cannot be stated as Static, as we cannot override static methods.
Examples of Virtual Function in Java
We will discuss some code examples of Virtual Function here.
Example #1
In this example, we will show how the virtual function showMe() is displaying different text depending on to which reference of object it is associated with. When it is associated with the “Head” type, it is showing messages from the parent class. When it is associated with the “Subordinate” type, it shows messages from the child class.
Code:
class Head {
public void showMe() {
System.out.println("I am Head");
}
}
class Subordinate extends Head {
@Override
public void showMe() {
System.out.println("I am Subordinate ");
}
}
public class VirtualFuntionDemo {
public static void main(String args[]) {
Head superObject = new Head();
superObject.showMe(); //method of super class or parent class is called
Head subObject = new Subordinate(); // upcasting
subObject.showMe();//method of sub class or child class is called by Parent reference, this is called "Virtual function"
Subordinate subObject2 = new Subordinate();
subObject2.showMe(); //method of sub class or child class is called
}
}Output:
Example #2
Let us take an example of the virtual function in the case of multilevel inheritance. In this example, we have two levels of inheritance is taken into account. In this example, we will show how the virtual function administration() is displaying different messages depending on which type of object it is associated with. When it is associated with the “State” type, it is showing messages from the parent class. When it is associated with the “District” type, it shows messages from its child class. Again in the second level of inheritance, when associated with the “Municipality” type, it shows messages from its child class of its parent, the “District” class.
Code:
class State{
void administartion() {
System.out.println("This is under state govt.");
}
}
class District extends State{
void administartion(){
System.out.println("This is under District Magistrate");
}
}
class Municipality extends District{
void administartion(){
System.out.println("This is under Mayor ");
}
}
public class VirtualFunctionDemo2 {
public static void main(String args[]){
State superObject=new State ();
State subObject=new District ();
State sub2Object=new Municipality ();
superObject. administartion ();
subObject.administartion (); // run time polymorphism occurs in virtual function happening in first level of heritance
sub2Object.administartion (); // run time polymorphism occurs in virtual function happening in 2nd level of heritance
}
}Output:
Example #3
Let us take another example of run time polymorphism in the case of multilevel inheritance. In this example, we have three levels of inheritance is taken into account. In this example, we will show how the virtual function whoami() is displaying different features depending on which type of object it is associated with. When it is associated with the “Cars” type, it is showing messages from the parent class. When it is associated with the “SUV” type, it shows messages from its child class. Again in the second level of inheritance, when associated with the “MPV” type, it shows messages from its child class of its parent, the “SUV” class. Again in the third level of inheritance, when associated with the “Hatchback” type, it shows messages from its child class of its parent, the “MPV” class.
Code:
class Cars{
void whoami() {
System.out.println("This is Car");
}
}
class SUV extends Cars{
void whoami(){
System.out.println("This is SUV");
}
}
class MPV extends SUV{
void whoami(){
System.out.println("This is MPV");
}
}
class Hatchback extends MPV{
void whoami(){
System.out.println("This is hatchback");
}
}
public class VirtualFunctionDemo3 {
public static void main(String args[]){
Cars superObject=new Cars();
Cars subObject=new SUV(); // object of child type : 1st level heritance
Cars sub2Object=new MPV(); // object of child type : 2nd level heritance
Cars sub3Object=new Hatchback(); // object of child type : 3rd level heritance
superObject.whoami();
subObject.whoami(); //run time polymorphism occurs in virtual function happening in first level of heritance
sub2Object.whoami(); //run time polymorphism occurs in virtual function happening in second level of heritance
sub3Object.whoami(); //run time polymorphism occurs in virtual function happening in third level of heritance
}
}Output:
Conclusion
This concludes our learning of the topic “Virtual Function in Java”. Write yourself the codes mentioned in the above examples in the java compiler and verify the output. Learning of codes will be incomplete if you will not write code by yourself.
Recommended Articles
This is a guide to Virtual Function in Java. Here we discuss how virtual function works in java, along with the examples and code implementation. You may also look at the following articles to learn more-
