Java Additional Topics

Virtual Function in Java

Last Updated : 16 Oct 2026

A virtual function is a method that supports runtime polymorphism by allowing a subclass to provide its own implementation of an inherited method. In Java, this behavior is achieved through method overriding and dynamic method dispatch rather than a dedicated virtual keyword.

In this chapter, you will learn about virtual functions in Java, how they work, and how they support runtime polymorphism.

What is a Virtual Function in Java?

A virtual function, also called a virtual method, is a method whose implementation is determined at runtime based on the actual type of the object. Java supports this behavior through method overriding.

Unlike C++, which uses the virtual keyword to declare virtual functions, Java does not require a special keyword for virtual methods. Most instance methods are dynamically dispatched, except methods that are static, private, or final.

Virtual functions are closely related to runtime polymorphism in Java and inheritance in Java. These concepts allow subclasses to provide specialized implementations of methods inherited from their parent classes.

How Do Virtual Functions Work in Java?

When a subclass overrides an instance method, Java determines which implementation to execute at runtime based on the actual object type rather than the reference variable's declared type. This behavior is known as dynamic method dispatch.

Static methods are resolved based on the reference type, private methods are not overridden, and final methods cannot be overridden. Therefore, these methods do not participate in runtime polymorphism through method overriding.

For more information, see Virtual Function in C++.

How to use Virtual function in Java

The virtual keyword is not used in Java to define the virtual function; instead, the virtual functions and methods are achieved using the following techniques:

We can override the virtual function with the inheriting class function using the same function name. Generally, the virtual function is defined in the parent class and override it in the inherited class.
The virtual function is supposed to be defined in the derived class. We can call it by referring to the derived class's object using the reference or pointer of the base class.
A virtual function should have the same name and parameters in the base and derived class.
For the virtual function, an IS-A relationship is necessary, which is used to define the class hierarchy in inheritance.
The Virtual function cannot be private, as the private functions cannot be overridden.
A virtual function or method also cannot be final, as the final methods also cannot be overridden.
Static functions are also cannot be overridden; so, a virtual function should not be static.
By default, Every non-static method in Java is a virtual function.
The virtual functions can be used to achieve oops concepts like runtime polymorphism.

In a nutshell, the methods or functions that can be used to achieve the polymorphism are the virtual functions or methods in Java.

Let's understand it with some examples:

Parent.Java:

   class Parent {
	void v1() //Declaring function
	{
	System.out.println("Inside the Parent Class");
	}
	}

Child.java:

public class Child extends Parent{
			void v1() // Overriding function from the Parent class
			{
			System.out.println("Inside the Child Class");
			}
			public static void main(String args[]){
			Parent ob1 = new Child(); //Refering the child class object using the parent class
			ob1.v1();
			}
			}

Output:

Inside the Child Class

From the above example, we have used the function v1() as the virtual function by overriding it in the Child class.

In Java Every non-static, non-final, and public method is a virtual function. These methods can be used to achieve polymorphism. The methods that can not be used to achieve the polymorphism never be virtual function.

A static, final, and private method never be the virtual function. We can not call the static method by using the object name or class name. Even if we try, it will not be able to achieve the polymorphism.

Java Interfaces as Virtual Function

An interface in Java is a blueprint of a class; it holds static constants and abstract methods. All Java Interfaces are considered virtual functions, as they depend on the implementing classes to provide the method implementation.

Consider the below example to understand the behavior of the interface:

interface Car{  
void print();  
}  
class BMW implements Car{  
public void print(){System.out.println("BMW X7");}  
public static void main(String args[]){  
BMW obj = new BMW();  
obj.print();  
 }  
}  

Output:

BMW X7

From the above example, we can see the interface's method is executed using the implementing class BMW.

Hence, we can also achieve polymorphism using the Interfaces.

Pure Virtual Function

A virtual function for which we are not required implementation is considered as pure virtual function. For example, Abstract method in Java is a pure virtual function. Consider the below example:

abstract class Animal {
		final void bark(){
		System.out.println("Dog");
		}
		abstract void jump(); // Abstract Method (Pure Virtual Function)
}
    class MyPet extends Animal{
		void jump(){
		System.out.println("MyPet is so sweet");
		}
}
public class Demo {
		public static void main(String args[]){
		Animal ob1 = new MyPet();
		ob1.jump();
		}
		}

Output:

MyPet is so sweet

From the above example, the jump() method is a pure virtual function.

Runtime Polymorphism

Runtime polymorphism is a process in which a call to an overridden method is resolved at runtime rather than compile time.

In runtime polymorphism, we will use the reference variable to call a method instead of a reference variable.

The virtual functions can be used to achieve runtime polymorphism.

Consider the below example to understand how the virtual function is used to achieve the runtime polymorphism:

class Javatpoint{
public void show() //Virtual Function
{
System.out.println("welcome to JavaTpoint");
}
}
class Training extends Javatpoint{
public void show(){
System.out.println("Best Java Training Institute");
}
public static void main(String args[]){
Javatpoint ob1 = new Training();
ob1.show();
}}

Output:

Best Java Training Institute

From the above example, we have achieved runtime polymorphism using the virtual function.

Summary

Below are some consideration points about the Virtual function in Java:

The Virtual Function is an ordinary function in Java.
We are not required to declare any explicit description to define the virtual function.
In Java, no virtual keyword is used to define the virtual function.
The Parent class pointer is used to refer to the object of the child class
the virtual function should be defined in the child class with the same name in the parent class.
All the instance methods in Java are considered the Virtual function except final, static, and private methods.

Next TopicJapanesedate-issupported-method-in-java-with-example

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.