Virtuel vs abstrait
Virtual et abstrait sont deux mots clés utilisés dans la plupart des langages de programmation orientés objet (OO) tels que Java et C #. Bien qu'il existe de légères différences dans ce que cela signifie dans différentes langues, les mots clés virtuels et abstraits donnent un sentiment d'implémentation partielle aux entités auxquelles il attache.
Abstrait
En règle générale, les classes abstraites, également appelées classes de base abstraites (ABC), ne peuvent pas être instanciées (une instance de cette classe ne peut pas être créée). Ainsi, les classes abstraites ne sont significatives que si le langage de programmation prend en charge l'héritage (capacité à créer des sous-classes à partir de l'extension d'une classe). Les classes abstraites représentent généralement un concept abstrait ou une entité avec une implémentation partielle ou non. Par conséquent, les classes abstraites agissent comme des classes de parents à partir desquelles les classes d'enfants sont dérivées, de sorte que la classe d'enfants partagera les caractéristiques incomplètes de la classe des parents et des fonctionnalités peuvent être ajoutées pour les compléter. Les classes abstraites peuvent contenir des méthodes abstraites. Les sous-classes prolongeant une classe abstraite peuvent implémenter ces méthodes abstraites (héréditaires). Si la classe d'enfants implémente toutes ces méthodes abstraites, c'est une classe concrète. Mais si ce n'est pas le cas, la classe d'enfants devient également une classe abstraite. Ce que tout cela signifie, c'est que lorsque le programmeur nomme une classe en tant que résumé, elle dit que la classe sera incomplète et qu'il aura des éléments qui doivent être complétés par les sous-classes héritées. C'est une belle façon de créer un contrat entre deux programmeurs, ce qui simplifie les tâches dans le développement de logiciels. Le programmeur, qui écrit du code pour hériter, doit suivre exactement les définitions de la méthode (mais bien sûr peut avoir sa propre implémentation). Dans Java et C #, les classes et méthodes abstraits sont déclarés en utilisant un mot-clé abstrait.
Virtuel
Les méthodes / fonctions virtuelles offrent la possibilité de remplacer éventuellement son comportement par une classe héritée (en utilisant une fonction avec la même signature). Le concept de fonction virtuelle est important dans le scénario suivant. Supposons qu'une classe soit dérivée par une classe d'enfants, puis chaque fois qu'un objet de la classe dérivée est utilisé, il peut se référer à un objet de la classe de base ou de la classe dérivée. Mais, le comportement des appels de méthode peut être ambigu si les méthodes de classe de base sont remplacées. Ainsi, afin de résoudre cette ambiguïté, un mot-clé virtuel est utilisé. Si la méthode est marquée virtuelle, alors la fonction de la classe dérivée est appelée (le cas échéant) ou bien la fonction de la classe de base est appelée. Par exemple, en C ++, le mot-clé virtuel est utilisé exactement à cet effet. En C #, le mot-clé virtuel est utilisé de la même manière, mais en outre, le remplacement du mot-clé doit être utilisé pour modifier toutes les méthodes remplacées. Mais en Java, il n'y a pas de mot-clé virtuel explicite. Toutes les méthodes non statiques sont considérées comme virtuelles. Les fonctions virtuelles sans corps sont appelées fonctions virtuelles pures. Dans Java et C #, les méthodes abstraites sont en fait purement virtuelles.
Différence entre virtuel et abstrait
Bien que l'abstrait et le virtuel soient deux mots-clés / concepts qui donnent une signification de mise en œuvre incomplète à ses entités associées, ils ont leurs différences. Les méthodes abstraites (qui doivent être définies dans les classes abstraites) n'ont pas du tout d'implémentation, tandis que les méthodes virtuelles peuvent avoir une implémentation. Si les méthodes abstraites sont étendues par une classe concrète, toutes les méthodes abstraites héréditaires doivent être mises en œuvre, tandis que les méthodes virtuelles héréditaires peuvent ou non être remplacées.