Você pode escrever funções / métodos virtuais em Java?

Consegue escrever funções virtuais em Java?

• Métodos de classe (porque normalmente cada instância contém informação como um ponteiro para uma mesa V sobre os seus métodos específicos, mas nenhuma instância está disponível aqui).
• métodos de instância privada (porque nenhuma outra classe pode acessar o método, a instância chamadora sempre tem o tipo da classe definidora em si e é, portanto, inequivocamente conhecido no tempo de compilação).

"funções virtuais normais

O seguinte exemplo é de uma versão antiga da página da Wikipédia mencionada em outra resposta.

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 {}

Resultado:

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

Exemplo com interfaces

Java Os Métodos de interface são todos virtuais. Eles devem ser virtuais porque dependem das classes de implementação para fornecer as implementações do método. O código a executar só será selecionado na hora de execução.

Por exemplo:

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
    }
}

Exemplo com funções virtuais com classes abstratas.

Semelhantes às interfaces classes Abstractas deve conter métodos virtuais porque eles dependem da implementação das classes de extensão. Por Exemplo:

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.
    }
}

Todas as funções em Java são virtuais por omissão.

Você tem que sair do seu caminho para escrever funções não-virtuais adicionando a palavra-chave "final".

Isto é o oposto do padrão C++/C#. As funções de classe são não-virtuais por padrão; você as faz adicionando o modificador "virtual".

Todos não-Privados os métodos de instância são virtuais por omissão em Java.

Em C++, os métodos privados podem ser virtuais. Isto pode ser explorado para o idioma não-virtual (NVI). Em Java, você precisaria proteger os métodos NVI.

A partir da especificação da linguagem Java, v3:

8.4.8.1 prevalecendo (por exemplo, métodos) um método de exemplo m1 declarado numa sobreposição de classes C outro método de exemplo, m2, declarado na classe A iff todos os seguintes são verdadeiros:

1. C é uma subclasse de A.
2. a assinatura de m1 é uma subvenção (§8.4.2) da Assinatura de m2.
3. quer * m2 é público, Protegido ou declarado com acesso padrão no a mesma embalagem que C, ou * m1 substitui um método m3, m3 distinto de m1, m3 distinto de m2, tal que o m3 se sobreponha ao m2.

SIM, você pode escrever "funções" virtuais em Java.