Virtual Method in Java: How Interfaces and Polymorphism Work Together!

A virtual method in Java is a non-static method that can be overridden by a subclass, enabling one of Java’s core strengths, runtime polymorphism. By default, all instance methods are virtual unless marked as final, private, or static. This allows Java to resolve method calls at runtime based on the actual object type rather than the reference type, resulting in more dynamic, flexible, and maintainable code.

In this blog, you will explore virtual function in Java in detail and their connection with inheritance and interfaces. 

Ready to build powerful applications and solve complex problems? Start your journey with online software engineering courses and develop the skills needed to write efficient code and design robust software systems.

What is a Virtual Function in Java? Key Features

In Java, the concept of a virtual method in Java underpins dynamic method invocation and supports core principles of object-oriented design. Though Java doesn't explicitly use the term, as languages like C++ do, it fully embraces the idea through method overriding. 

When a subclass provides its own version of a method defined in a superclass, Java ensures the correct method is executed based on the object's true type at runtime. This mechanism promotes modularity, reusability, and clean architecture in software development.

In 2025, programming and AI skills remain in high demand as businesses seek to innovate and improve efficiency. To enhance your expertise in Java and other technologies, consider these top courses:

• Masters in Artificial Intelligence and Machine Learning - IIITB Program
• Executive Diploma in Machine Learning and AI with IIIT-B
• Advanced Generative AI Certification Course

Code Example: Virtual Function in Java

This example shows how a method is overridden in a subclass to provide specific behavior.

Code Snippet:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound();  // Output: Dog barks
    }
}

Output: 

Dog barks

Explanation:

• The sound() method is originally defined in the Animal class and then overridden in the Dog subclass to provide a behavior specific to dogs.
• When you call sound() on an Animal reference that points to a Dog object, Java does not call the Animal version. Instead, it calls the overridden method in the Dog class.
• This decision is made at runtime by the Java Virtual Machine (JVM) through dynamic method dispatch, a core part of Java’s polymorphism.
• This shows that Java treats all non-static methods as virtual by default, allowing the program to decide which method to execute based on the actual object's type.
• The output displays the dog’s version of the sound() method, demonstrating that the JVM uses the real object type (not the reference type) to resolve method calls dynamically.

Note:

The @Override annotation ensures that the method in the subclass is correctly overriding a method from the superclass. If the method signature in the subclass does not match any method in the superclass, the compiler will produce an error. This helps avoid mistakes, such as typos in method names or incorrect method parameters.

With a solid understanding of what is virtual function in Java, you can now explore its key features, which enable flexibility in object-oriented design.

Features of Virtual Method in Java

Virtual function in Java are equipped with key features that enable dynamic behavior and enhance code reusability. This section explores these features, including how dynamic method dispatch and method overriding drive polymorphism, making Java’s object-oriented design both flexible and powerful.

Also Read: What is a Static Method & Static Keyword in Java?

Let’s compare Static vs Virtual Function Methods in Java and explore their key differences and use cases.

Static vs Virtual Method in Java

While both static and virtual functions serve important purposes in Java, they differ significantly in terms of their behavior and functionality. Static methods are bound at compile time, whereas virtual functions rely on runtime method resolution. 

Below is a comparison of static and virtual method in Java:

Wondering how data patterns relate to virtual method in Java? Enroll in upGrad's 6-hours Analyzing Patterns in Data and Storytelling course to help you enhance your coding expertise!

To better understand how virtual functions provide flexibility and enhance code reusability, let's explore how to implement them in Java.

How to Implement Virtual Method in Java?

Implementing virtual method in Java is all about method overriding, a key part of polymorphism. By overriding methods in subclasses, you can customize their behavior while keeping the method signature consistent. 

In this section, you’ll learn how to implement virtual functions step by step, with practical examples to help you understand how it works in action.

To implement virtual function in Java, the following steps are essential:

• Declare the method in the parent class: The method should be non-static and non-final, as static and final methods cannot be overridden.
• Override the method in the subclass: Provide specific implementation for the method in the subclass.
• Invoke the method: Use an object of the subclass to call the overridden method. Java will resolve the correct method based on the actual object type at runtime.

Code Example: Virtual Function in a Practical Scenario

Consider a scenario where you are designing a system to represent different types of employees. You have a generic Employee class, and subclasses for Manager and Developer. 

Both subclasses override a method getSalary(), but each has a different implementation depending on their role. This is an ideal example of applying a virtual method in Java.

Code Snippet:

class Employee {
    // Virtual function
    double getSalary() {
        return 50000;
    }
}

class Manager extends Employee {
    @Override
    double getSalary() {
        return 80000;
    }
}

class Developer extends Employee {
    @Override
    double getSalary() {
        return 60000;
    }
}

public class Company {
    public static void main(String[] args) {
        Employee emp1 = new Manager();
        Employee emp2 = new Developer();
        
        System.out.println("Manager's Salary: " + emp1.getSalary());  // Output: 80000
        System.out.println("Developer's Salary: " + emp2.getSalary());  // Output: 60000
    }
}

Output:

Manager's Salary: 80000
Developer's Salary: 60000

Explanation:

• The getSalary() method in the Employee class acts as a virtual function, meaning it provides a default implementation that subclasses can override.
• The subclasses Manager and Developer each provide their own version of getSalary(), returning salary values specific to their roles—80000 for Manager and 60000 for Developer.
• In the main() method, although emp1 and emp2 are declared as Employee references, they actually point to Manager and Developer objects, respectively.
• When calling getSalary() on these references, Java uses runtime method dispatch to determine which version of the method to execute, based on the actual object type rather than the reference type.
• This is an example of polymorphism, where the same method call can lead to different behaviors depending on the object it is called on.
• The output confirms this: calling emp1.getSalary() prints 80000, reflecting the Manager’s salary, while emp2.getSalary() prints 60000, the Developer’s salary.
• This approach allows you to write flexible and reusable code, where a single reference type can point to different subclass objects, and the correct method implementation runs automatically.
• Polymorphism helps manage different employee types efficiently, without needing separate code for each role, simplifying maintenance and extension of the system.

Now that we've covered virtual methods in Java, let's see how interfaces enhance polymorphism, with clear roles and practical examples.

Virtual Function with Interface in Java: Understanding Polymorphism with Examples

In Java, interfaces play a crucial role in enabling virtual functions by enforcing method implementation across different classes. When a method is declared in an interface, it acts as a contract that all implementing classes must fulfill, allowing dynamic method resolution at runtime. This mechanism is fundamental to achieving polymorphism, where the exact method invoked depends on the actual object type, promoting flexible and extensible designs.

• Abstract Method Declarations: Interface methods are abstract by default, requiring implementing classes to override them with concrete behavior.
  Runtime Polymorphism: By referencing objects through interface types, Java uses dynamic dispatch to call the appropriate overridden method based on the actual class instance.
• Decoupling via Interfaces: Interfaces enable loose coupling between components, allowing you to swap implementations without changing client code, essential for scalable architectures.
• Support Across Java Versions: Since Java 8, interfaces can include default methods, but virtual function behavior applies primarily to abstract methods requiring overriding.
• Consistent Method Signatures: Implementing classes must maintain the method signature, ensuring interface contracts are upheld for reliable polymorphic calls.

Example: Virtual Function in Interface Implementation

The following code shows how different classes implement a common interface with a virtual function for calculating the area of geometric shapes.

Code Snippet:

// Defining the interface with a virtual function
interface Shape {
    double calculateArea();  // Virtual function
}

// Implementing the interface in the Rectangle class
class Rectangle implements Shape {
    double length, width;

    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;  // Rectangle's specific implementation
    }
}

// Implementing the interface in the Circle class
class Circle implements Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;  // Circle's specific implementation
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Rectangle(5, 10);
        Shape shape2 = new Circle(7);

        System.out.println("Rectangle Area: " + shape1.calculateArea());  // Output: 50.0
        System.out.println("Circle Area: " + shape2.calculateArea());  // Output: 153.93804002589985
    }
}

Output:

Rectangle Area: 50.0
Circle Area: 153.93804002589985

Explanation:

• The Shape interface declares the method calculateArea(), which acts as a virtual function that all implementing classes must define. This sets a common contract for different shapes.
• The Rectangle and Circle classes implement the Shape interface, each providing their own version of calculateArea() that calculates area according to their specific formulas.
• In the main() method, variables shape1 and shape2 are declared as type Shape but hold objects of Rectangle and Circle respectively.
• When calculateArea() is called on these references, Java uses runtime polymorphism to invoke the correct method implementation based on the actual object type.
• This allows the program to treat different shapes uniformly through the interface, while still executing shape-specific behavior.
• The output reflects this dynamic method resolution:
  • shape1.calculateArea() returns 50.0, the area of the rectangle (5 * 10).
  • shape2.calculateArea() returns approximately 153.94, the area of the circle using π * radius².
• This design promotes flexibility and extensibility, allowing new shapes to be added easily by implementing the same interface without changing existing code.

Ready to enhance your Java and OOP skills? Enroll in upGrad’s AI-Powered Full Stack Development Course by IIITB and learn advanced concepts like virtual methods and polymorphism.

Building on the concept of virtual functions with interfaces, let's explore how runtime polymorphism and method overriding further enhance flexibility in Java.

Runtime Polymorphism in Java: Method Overriding and Virtual Method in Java

Runtime polymorphism in Java is the ability of the program to decide during execution which method to call. This feature allows Java to handle method calls dynamically, based on the actual object type at runtime.

Below are key points that clarify how runtime polymorphism is achieved and its significance when using virtual method in Java.

Tired of writing repetitive code? The upGrad PG Diploma in Data Science – IIIT Bangalore teaches you how Java virtual methods enable scalable OOP patterns for real-world data workflows.

Understanding runtime polymorphism through method overriding helps you How Abstract Methods Represent Pure Virtual Function in Java?

In C++, pure virtual functions use the virtual keyword without implementation, forcing subclasses to override them, making the class abstract.

Java doesn't use the virtual keywor,d but achieves the same with abstract methods inside abstract classes. These methods lack implementation and must be overridden by subclasses, ensuring specific behaviors.

Though the syntax differs, Java’s abstract methods function like C++'s pure virtual functions, supporting polymorphism and enforcing a consistent design.

Curious about how cloud computing can enhance your coding skills? upGrad's Fundamentals of Cloud Computing course offers the perfect foundation, just like abstract methods lay the groundwork for pure virtual functions in Java.

After understanding abstract methods, let’s quickly compare virtual vs pure virtual functions to clarify their roles in class design.

Virtual Functions vs. Pure Virtual Function in Java: Key Differences

In Java, virtual functions are implemented through method overriding, enabling runtime polymorphism where subclasses provide specific method implementations. Pure virtual functions, as in C++, do not exist explicitly in Java but are conceptually represented by abstract methods in abstract classes or interfaces. 

Abstract methods must be overridden by subclasses, enforcing a contract similar to pure virtual functions and ensuring no default implementation exists. Understanding this distinction helps you design Java applications that leverage polymorphism effectively while adhering to strong abstraction principles.

In this comparison, virtual functions offer flexibility in Java, while pure virtual functions in other languages, like C++, provide a stricter level of enforcement.

Lost in messy codebases? The upGrad PG Certificate in Data Science builds your confidence to apply Java virtual methods and craft flexible, object-oriented solutions from day one.

After examining the key differences between virtual functions and pure virtual function in Java, it’s important to look at their advantages and disadvantages.

Advantages and Disadvantages of Virtual Method in Java

Virtual functions in Java offer great benefits, like increased flexibility, code reuse, and support for runtime polymorphism, making them essential in object-oriented programming. However, they also come with challenges, such as performance overhead and debugging difficulties. 

In this section, you’ll learn the pros and cons of virtual functions, so you can make better design choices for your projects.

Here are the main advantages of virtual functions in Java:

While virtual functions offer significant advantages, it is also important to consider their potential drawbacks when implementing them in Java.

Want to master Java's object-oriented principles and avoid the pitfalls of virtual functions? Enroll in upGrad's Java Object-Oriented Programming course today!

To make the most of virtual functions in Java while minimizing potential drawbacks, it’s essential to follow some proven best practices. Let’s explore how you can implement them effectively.

Best Practices to Optimize Virtual Function in Java

When working with virtual functions in Java, following best practices helps you write efficient, manageable, and understandable code. By adopting these principles, you can enhance the scalability of your Java applications while minimizing common challenges like code complexity and unexpected runtime behavior. 

The following best practices are designed to help you optimize virtual function usage, ensuring smoother development and more reliable performance in your projects.

Best Practice 1: Use Interfaces and Abstract Classes

Using interfaces and abstract classes provides a clear structure to your code, making it easier to decouple different components. They allow for better abstraction, which is essential for managing virtual functions effectively. 

To implement this, here are some key insights:

• Interfaces: Use interfaces to define a contract for your classes. Interfaces allow different classes to implement the same methods, supporting polymorphism.
• Abstract Classes: Abstract classes are ideal for providing a base implementation of some methods while leaving others for subclasses to implement. They help maintain a clean and clear structure.

By using interfaces and abstract classes, you ensure your codebase remains flexible and extensible.

Also Read: How to Code, Compile, and Run Java Projects: A Beginner’s Guide

Best Practice 2: Keep Method Overriding Consistent

When overriding methods in subclasses, consistency is crucial. Ensuring that the method behavior and signature remain consistent makes the code easier to follow and maintain. 

Consider these points to maintain consistency:

• Method Signatures: Maintain the same method signature when overriding virtual functions. This avoids confusion and ensures proper method resolution at runtime.
• Behavior Consistency: Overridden methods should exhibit behavior consistent with the original method in the parent class. This ensures your code behaves as expected.

Consistency in method overriding provides reliability and helps maintain a predictable behavior across the codebase.

Also Read: Types of Polymorphism in Java [Static & Dynamic Polymorphism with Examples]

Best Practice 3: Favor Composition Over Inheritance

Instead of relying on inheritance for extending functionality, favor composition. Using composition enables you to create more flexible and maintainable systems, as it avoids deep and complex inheritance hierarchies. 

Here are some tips to apply this practice effectively:

• Flexibility: Composition provides flexibility by allowing you to mix and match behaviors. This reduces the tight coupling that inheritance might introduce.
• Avoid Deep Hierarchies: By favoring composition, you reduce the need for long, complicated inheritance chains, making your code easier to maintain.

Favoring composition enhances the flexibility and maintainability of your code, reducing complexity.

Also Read: What are the Types of Inheritance in Java? Examples and Tips to Master Inheritance

Best Practice 4: Avoid Overusing Virtual Functions

While virtual functions provide powerful polymorphism capabilities, overusing them can lead to complex, hard-to-maintain code. It's essential to use them only when necessary to prevent unnecessary abstraction and complexity in your applications.

Key points to remember include:

• Limit Overriding: Avoid overriding methods unless it's essential for adding specific functionality. Too many overrides can make your codebase difficult to manage.
• Simplicity: Keep your code simple and focused. Overusing virtual functions can complicate things unnecessarily, especially in large applications.

By avoiding overuse, you ensure that your code remains simple and maintainable.

Also Read: A Complete Guide to Java Keywords

Best Practice 5: Follow the Liskov Substitution Principle (LSP)

The Liskov Substitution Principle ensures that subclasses can replace their base classes without affecting the correctness of your program. This principle is vital when working with virtual functions, as it guarantees that the substitution of objects will not introduce unexpected behavior.

Consider the following strategies for adhering to LSP:

• Correctness: Always ensure that when a subclass replaces a base class, the behavior remains consistent. This prevents issues related to polymorphism.
• Maintain Functionality: Following LSP ensures that overridden methods in subclasses do not break the intended functionality of the parent class methods.

By adhering to LSP, you maintain the correctness and reliability of your code.

Also Read: Understanding the Differences Between Inheritance and Polymorphism in Java

Best Practice 6: Document Override Methods Clearly

Documenting overridden methods is essential for clarity. When you override a method, it is important to clearly explain its purpose and behavior. This will help other developers understand how your subclass changes the behavior of the parent class method.

Here’s how to document effectively:

• Clarity: Use comments and documentation to explain the purpose of overriding the method. This helps maintain clarity in large projects.
• Consistency: Consistent documentation ensures that other developers can quickly understand the behavior of overridden methods.

Proper documentation ensures that your code is understandable and maintainable for other developers.

Also Read: What is Coding? A Comprehensive Guide to Software Engineers in 2025

Best Practice 7: Use the @Override Annotation

The @Override annotation is a powerful tool that ensures the method signature in the subclass matches the method in the superclass. Using this annotation can prevent errors during the development process and provide compile-time checks.

Benefits of using the @Override annotation include:

• Error Prevention: The @Override annotation helps catch errors where the method signatures do not match between the superclass and subclass.
• Improved Code Quality: By using this annotation, you ensure that your code is more reliable and adheres to the expected method signature.

The @Override annotation enhances code quality and prevents common errors during development.

Also Read: Types of Variables in Java: Java Variables Explained

Best Practice 8: Minimize Method Visibility

To reduce unnecessary exposure of virtual functions, it is recommended to limit their visibility. Restricting access to methods when they are not needed outside the class or package ensures better encapsulation and protects the integrity of your code.

Key points to follow include:

• Encapsulation: Minimize method visibility to keep your code secure and prevent unintended access to internal methods.
• Package-Private or Private: Use package-private or private modifiers for methods that are not intended to be overridden or called from outside the class.

Minimizing method visibility enhances security and helps maintain the integrity of your codebase.

Also Read: Difference Between Overloading and Overriding in Java: Understanding the Key Concepts in 2025

Best Practice 9: Avoid Changing Method Signature in Subclasses

Changing the method signature in a subclass, including the return type or parameters, can break existing code dependencies. Here are the best practices to avoid signature changes.

• Signature Consistency: Never change the return type or parameters of the method in the subclass. This can create unexpected behavior and bugs.
• Maintain Dependencies: By keeping method signatures the same, you ensure that other parts of the system relying on those methods continue to work smoothly.

Maintaining method signature consistency preserves code compatibility and prevents errors.

How upGrad Can Help You Advance Your Career in Coding?

A virtual method in Java is any non-static method that a subclass can override. These methods support runtime polymorphism, where the JVM determines the method to execute based on the actual object type, not the reference type. This allows dynamic method dispatch, making Java programs more flexible, extensible, and aligned with object-oriented design principles.

If you're looking to strengthen your Java skills, upGrad offers practical, mentor-led programs that bridge theory with hands-on experience. These programs are ideal for building confidence in key concepts like polymorphism, inheritance, and interface-based design.

Here are some of the top courses available to help you grow.

• Future-Proof Your Tech Career with AI-Driven Full-Stack Development
• Core Java Basics
• Advanced JavaScript for All

Feeling unsure about where to begin with your programming career? Connect with upGrad’s expert counselors or visit your nearest upGrad offline centre to explore a learning plan tailored to your goals. Transform your programming journey today with upGrad!

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

References:
https://6sense.com/tech/languages/java-market-share
https://www.tiobe.com/tiobe-index/