Comment fonctionnent les fonctions virtuelles en C# et Java?

Comment fonctionnent les fonctions virtuelles en Java?

codage les intervieweurs adorent cette question. Oui. Bien que Java n'ait pas de mot-clé virtuel, Java a des fonctions virtuelles et vous pouvez les écrire.

dans la programmation orientée objet, un fonction virtuelle ou méthode virtuelle est une fonction ou une méthode dont le comportement peut être redéfinie dans une classe qui hérite d'une fonction avec la même signature. Ce concept est une partie très importante du polymorphisme partie de la programmation orientée objet (POO).

poser une question d'architecture sur un langage spécifique comme celui-ci nécessite de grandes compétences en communication et une profonde maîtrise des principes sous-jacents du compilateur Java, en particulier les interfaces, Les classes abstraites, et comment fonctionne l'héritage.

guidez l'intervieweur vers un exemple précis d'une fonction virtuelle.

Oui vous pouvez écrire des fonctions virtuelles en Java avec des interfaces.

Java méthodes d'interface "virtuelle pure", car ils sont conçus pour être substituée. Par exemple:

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 implementing applyBrakes()
       System.out.println("Brakes applied"); //function, proving it is virtual.
    }
}

Oui, vous pouvez écrire des fonctions virtuelles Java classes abstraites.

Java classes abstraites contiennent implicitement des méthodes "virtuelles", implémentées par des classes l'étendant. Par Exemple:

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 virtual function because it
}                                     //is part of an abstract class and isn't
                                      //final.  
class MyDog extends Dog{
    void jump(){
        System.out.println("boing");    //here jump() is being overridden, a 
    }                                   //demonstration that it is virtual.
}
public class Runner {
    public static void main(String[] args) {
        MyDog myDog = new MyDog();       //instantiating myDog
        myDog.jump();                    //calling the overridden function jump()
    }
}

vous pouvez forcer une fonction à ne pas être virtuelle dans une classe générique en rendant final

Par exemple:

class myJavaFoobarClass {

    final boolean giveMeTrueFunction()   //this Java function is NOT virtual
    {                                    //because final keyword prevents this
        return true;                     //function from being modified in a
    }                                    //subclass.

    boolean isItRainingFunction()   //this Java function IS virtual because
    {                               //without the final keyword, the function
        return false;               //can be overridden in a subclass.
    }
}

il n'y a pas de mot clé virtuel en Java au moins.

il se résout juste à la version la plus dérivée de n'importe quelle méthode que vous appelez...

class A{
void sayhi(){ System.out.println("A");}
}
class B extends A{
void sayhi(){ System.out.println("B");}
}

A a = new B();
a.sayhi();

imprimera "B".

vous pouvez créer des méthodes "virtuelles pures" en déclarant une classe abstraite et en laissant les méthodes virtuelles pures déclarées mais non mises en œuvre. Ou en utilisant interface / implements au lieu de class / extends. Une interface est simplement une classe où toutes les méthodes sont virtuelles pures. Cela a le bonus ajouté qu'une classe peut implémenter plusieurs interfaces, car contrairement à C++ une classe Java ne peut hériter directement qu'une autre classe.

EDIT:

En réponse à votre commentaire, Naveen:

si vous avez dit A A = nouveau A (); A. sayhi(); it would print "A".

la terminologie java est dynamique. Vous pouvez le considérer comme virtuel, mais cela peut embrouiller certains devs Java. ceux qui ne connaissent pas le C++, au moins. En Java il n'y a pas explicite pointeurs, donc nous n'avons pas besoin de se soucier de virtuel / non virtuel. Il n'y a pas de VTables, il suffit de revenir en arrière de la classe et de ses ancêtres jusqu'à ce que vous trouviez une implémentation de la méthode que vous voulez. Il n'y a qu'un seul héritage, donc vous n'avez pas à vous soucier de l'ordre des constructeurs (c'est toujours de bas en haut).

EN C++ vous avez un comportement différent si vous avez des méthodes virtuelles et faites quelque chose comme

a->sayhi();

où a était a* pointant vers une instance de B à la place

a.sayhi();

où a était un objet de type A contenant un objet de type B

en Java, la fonction virtuelle est totalement différente. En Java, une fonction virtuelle signifie une fonction qui peut être supplantée dans ses sous-classes. Donc toutes les méthodes non statiques de Java sont des fonctions virtuelles. Seules les fonctions finale et privée ne sont pas héritées, donc elles ne sont pas virtuelles.

nous pouvons donc dire que toutes les fonctions non statiques qui ne sont pas finales et privées sont des fonctions virtuelles en Java.

toutes les langues supportant le polymorphisme utilisent vtables pour résoudre les appels de méthode à la fonction correcte. Ainsi que Java et .NET.

ils compilent tous les deux dans un langage intermédiaire (IL pour .NET et byte code pour java) mais le vtable n'est pas visible dans ce langage intermédiaire. Il est supporté par le moteur sous-jacent (CLR pour .NET)

Je suis sûr que Java n'utilise pas vtables, puisqu'il est capable de supporter la compatibilité binaire.

pour clarifier: le vtable est construit lorsque la classe derived/sub est compilée. Si la disposition de la base/super classe change alors le vtable pour le d/s doit être recompilé. En Java, ce n'est pas le cas. Vous pouvez modifier le b/s sans avoir à recompiler le d/s.

Hmmm. Il est possible qu'un vtable soit construit à l'instant de l'exécution. lorsque la classe est chargée. Auquel cas, Java et C++ serait de même de même mais en différent.

les fonctions virtuelles pures sont en C++. C # utilise des Interfaces pour servir le même but, donc je vous suggère de suivre cette voie.