Can you write virtual functions / methods in Java?

From wikipedia

In Java, all non-static methods are by default "virtual functions." Only methods marked with the keyword final, which cannot be overridden, along with private methods, which are not inherited, are non-virtual.

Can you write virtual functions in Java?

Yes. In fact, all instance methods in Java are virtual by default. Only certain methods are not virtual:

• Class methods (because typically each instance holds information like a pointer to a vtable about its specific methods, but no instance is available here).
• Private instance methods (because no other class can access the method, the calling instance has always the type of the defining class itself and is therefore unambiguously known at compile time).

Here are some examples:

"Normal" virtual functions

The following example is from an old version of the wikipedia page mentioned in another answer.

import java.util.*;public class Animal {   public void eat()    {       System.out.println("I eat like a generic Animal.");    }   public static void main(String[] args)    {      List<Animal> animals = new LinkedList<Animal>();      animals.add(new Animal());      animals.add(new Fish());      animals.add(new Goldfish());      animals.add(new OtherAnimal());      for (Animal currentAnimal : animals)       {         currentAnimal.eat();      }   }}class Fish extends Animal {   @Override   public void eat()    {       System.out.println("I eat like a fish!");    }}class Goldfish extends Fish {   @Override   public void eat()    {       System.out.println("I eat like a goldfish!");    }}class OtherAnimal extends Animal {}

Output:

I eat like a generic Animal.I eat like a fish!I eat like a goldfish!I eat like a generic Animal.

Example with virtual functions with interfaces

Java interface methods are all virtual. They must be virtual because they rely on the implementing classes to provide the method implementations. The code to execute will only be selected at run time.

For example:

interface Bicycle {         //the function applyBrakes() is virtual because    void applyBrakes();     //functions in interfaces are designed to be }                           //overridden.class ACMEBicycle implements Bicycle {    public void applyBrakes(){               //Here we implement applyBrakes()       System.out.println("Brakes applied"); //function    }}

Example with virtual functions with abstract classes.

Similar to interfaces Abstract classes must contain virtual methods because they rely on the extending classes' implementation. For Example:

abstract class Dog {                       final void bark() {               //bark() is not virtual because it is         System.out.println("woof");   //final and if you tried to override it    }                                 //you would get a compile time error.    abstract void jump();             //jump() is a "pure" virtual function }                                     class MyDog extends Dog{    void jump(){        System.out.println("boing");    //here jump() is being overridden    }                                  }public class Runner {    public static void main(String[] args) {        Dog dog = new MyDog();       // Create a MyDog and assign to plain Dog variable        dog.jump();                  // calling the virtual function.                                     // MyDog.jump() will be executed                                      // although the variable is just a plain Dog.    }}

All functions in Java are virtual by default.

You have to go out of your way to write non-virtual functions by adding the "final" keyword.

This is the opposite of the C++/C# default. Class functions are non-virtual by default; you make them so by adding the "virtual" modifier.