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

É possível escrever métodos virtuais em Java, como se faria em C ++?

Ou existe uma abordagem Java apropriada que você possa implementar que produz um comportamento semelhante? Poderia, por favor, ter alguns exemplos?

Da wikipedia

Em Java , todos os métodos não estáticos são, por padrão, " funções virtuais " . Somente os métodos marcados com a palavra - chave final , que não podem ser substituídos, juntamente com os métodos privados , que não são herdados, não são virtuais .

Você pode escrever funções virtuais em Java?

Sim. De fato, todos os métodos de instância em Java são virtuais por padrão. Apenas certos métodos não são virtuais:

• Métodos de classe (porque normalmente cada instância contém informações como um ponteiro para uma vtable sobre seus métodos específicos, mas nenhuma instância está disponível aqui).
• Métodos de instância privada (como nenhuma outra classe pode acessar o método, a instância de chamada sempre tem o tipo da própria classe de definição e, portanto, é inequivocamente conhecida em tempo de compilação).

aqui estão alguns exemplos:

Funções virtuais "normais"

O exemplo a seguir é de uma versão antiga da página da Wikipedia 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:

Eu como como um animal genérico.
Eu como como um peixe!
Eu como como um peixe dourado!
Eu como como um animal genérico.

Exemplo com funções virtuais com interfaces

Os métodos de interface Java 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 ser executado será selecionado apenas no tempo 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.

Semelhante às interfaces As classes abstratas devem conter métodos virtuais, porque contam com a implementação das classes estendidas. 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 padrão.

Você precisa fazer o possível para escrever funções não virtuais adicionando a palavra-chave "final".

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

Todos os métodos de instância não privados são virtuais por padrão em Java.

No C ++, métodos privados podem ser virtuais. Isso pode ser explorado para o idioma da interface não virtual (NVI). Em Java, você precisa proteger os métodos substituíveis pelo NVI.

Na especificação da linguagem Java, v3:

8.4.8.1 Substituição (por métodos de instância) Um método de instância m1 declarado em uma classe C substitui outro método de instância, m2, declarado na classe A, se todas as seguintes opções forem verdadeiras:

1. C é uma subclasse de A.
2. A assinatura de m1 é uma subsignatura (§8.4.2) da assinatura de m2.
3. * M2 é público, protegido ou declarado com acesso padrão no mesmo pacote que C, ou * m1 substitui um método m3, m3 distinto de m1, m3 distinto de m2, de modo que m3 substitui m2.

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

Em Java, todas as variáveis ​​e funções públicas (não privadas) são virtuais por padrão. Além disso, variáveis ​​e funções usando a palavra-chave final não são virtuais .