Können Sie virtuelle Funktionen/Methoden in Java schreiben?

Können Sie virtuelle Funktionen in Java schreiben?

Ja. Tatsächlich sind alle Instanzmethoden in Java standardmäßig virtuell. Nur bestimmte Methoden sind nicht virtuell:

• Klassenmethoden (normalerweise enthält jede Instanz Informationen wie einen Zeiger auf eine vtable über ihre spezifischen Methoden, hier ist jedoch keine Instanz verfügbar).
• Private Instanzmethoden (da keine andere Klasse auf die Methode zugreifen kann, hat die aufrufende Instanz immer den Typ der definierenden Klasse selbst und ist daher zur Kompilierzeit eindeutig bekannt).

Hier sind einige Beispiele:

"Normale" virtuelle Funktionen

Das folgende Beispiel stammt aus einer alten Version der in einer anderen Antwort erwähnten Wikipedia-Seite.

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

Ausgabe:

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

Beispiel mit virtuellen Funktionen mit abstrakten Klassen. 

Ähnlich zu Interfaces Abstrakte Klassenmust enthalten virtuelle Methoden, da sie auf der Implementierung der Erweiterungsklassen basieren. Zum Beispiel:

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

Alle Funktionen in Java sind standardmäßig virtuell.

Sie müssen nicht nur virtuelle Funktionen schreiben, indem Sie das Schlüsselwort "final" hinzufügen.

Dies ist das Gegenteil von C++/C #. Klassenfunktionen sind standardmäßig nicht virtuell. Sie machen sie so, indem Sie den "virtuellen" Modifikator hinzufügen.

Alle nicht-privaten Instanzmethoden sind in Java standardmäßig virtuell. 

In C++ können private Methoden virtuell sein. Dies kann für das NVI-Idiom (Non-Virtual-Interface) ausgenutzt werden. In Java müssen Sie die überschreibbaren NVI-Methoden schützen.

Aus der Java-Sprachspezifikation, v3:

8.4.8.1 Überschreiben (durch Instanzmethoden) Eine Instanzmethode m1 in einer Klasse C deklariert überschreibt eine andere Instanzmethode, m2, deklariert in Klasse A iff alle folgenden sind wahr:

1. C ist eine Unterklasse von A.
2. Die Signatur von m1 ist eine Unterschrift (§8.4.2) der Signatur von m2.
3. Entweder * m2 ist öffentlich, geschützt oder mit Standardzugriff in der .__ deklariert. dasselbe Paket wie C oder * m1 überschreibt eine Methode m3, m3, die sich von m1, m3 unterscheidet. m2, so dass m3 m2 überschreibt.

Ja, Sie können virtuelle "Funktionen" in Java schreiben.

In Java sind alle öffentlichen (nicht privaten) Variablen und Funktionen standardmäßig Virtual . Außerdem sind Variablen und Funktionen, die das Schlüsselwort final verwenden, nicht virtuell .