Fonction virtuelle en Java
- Fonction virtuelle en Java
- Fonctions virtuelles dans Java Bean
- Fonctions non virtuelles en Java
- Fonctions virtuelles dans l’interface Java
Ce didacticiel présente ce qu’est une fonction/méthode virtuelle en Java et comment utiliser la fonction virtuelle en Java.
Une fonction définie dans une classe de base et pouvant être remplacée dans une classe dérivée est appelée fonction virtuelle. Le concept de fonction virtuelle était utilisé en C++ et en Java par défaut ; toutes les méthodes non privées et non finales sont des méthodes virtuelles.
En C++, nous utilisons un mot-clé virtual pour créer des fonctions virtuelles, mais Java n’a pas ce mot-clé. Et en plus de cela, toutes les méthodes non privées et non finales sont virtuelles.
Le concept de fonction virtuelle est utile en termes de concepts de programmation orientée objet et de polymorphisme. Comprenons par quelques exemples.
Fonction virtuelle en Java
Dans cet exemple, nous avons créé une classe Human qui contient une méthode virtuelle eat(). Comme il s’agit d’une méthode virtuelle, elle peut être redéfinie dans la classe dérivée/enfant, comme nous l’avons fait dans l’exemple ci-dessous. Les deux méthodes ont la même signature, et lorsque nous appelons la fonction, seule la méthode de la classe enfant s’exécute. Voir l’exemple ci-dessous.
class Human {
void eat(String choice) {
System.out.println("I would like to eat - " + choice + " now");
}
}
public class SimpleTesting extends Human {
void eat(String choice) {
System.out.println("I would like to eat - " + choice);
}
public static void main(String[] args) {
SimpleTesting simpleTesting = new SimpleTesting();
simpleTesting.eat("Pizza");
simpleTesting.eat("Chicken");
}
}
Production :
I would like to eat - Pizza
I would like to eat - Chicken
Fonctions virtuelles dans Java Bean
Les fonctions getter d’une classe bean/POJO sont également virtuelles et peuvent être remplacées par la classe enfant. Voir l’exemple ci-dessous.
public class SimpleTesting extends Student {
public int getId() {
System.out.println("Id : " + id);
return id;
}
public String getName() {
System.out.println("Name : " + name);
return name;
}
public int getAge() {
System.out.println("Age : " + age);
return age;
}
public static void main(String[] args) {
SimpleTesting student = new SimpleTesting();
student.setId(101);
student.setName("Rohan");
student.setAge(50);
student.getId();
student.getName();
student.getAge();
}
}
class Student {
int id;
String name;
int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Production :
Id : 101
Name : Rohan
Age : 50
Fonctions non virtuelles en Java
Les fonctions privées ou finales ne sont pas virtuelles, elles ne peuvent donc pas être remplacées par la classe enfant. Dans cet exemple, nous avons créé deux fonctions, l’une est finale et la seconde est privée. Nous avons essayé de les remplacer dans la classe enfant, mais le compilateur Java a généré une erreur en raison de la fonction non virtuelle. Voir l’exemple et la sortie ci-dessous.
class Human {
// non-virtual method
final void eat(String choice) {
System.out.println("I would like to eat - " + choice);
}
// non-virtual method
private void buy(String item) {
System.out.println("Buy me a " + item);
}
}
public class SimpleTesting extends Human {
// non-virtual method
void eat(String choice) {
System.out.println("I would like to eat - " + choice);
}
// non-virtual method
void buy(String item) {
System.out.println("Buy me a " + item);
}
public static void main(String[] args) {
SimpleTesting simpleTesting = new SimpleTesting();
simpleTesting.eat("Pizza");
simpleTesting.buy("Pizza");
simpleTesting.eat("Chicken");
simpleTesting.buy("Chicken");
}
}
Production :
java.lang.IncompatibleClassChangeError: class SimpleTesting overrides final method Human.eat(Ljava/lang/String;)
---Cannot override the final method from Human---
Fonctions virtuelles dans l’interface Java
Les fonctions/méthodes d’une interface sont virtuelles par défaut car elles sont publiques par défaut et sont censées être remplacées par la classe enfant. Dans l’exemple ci-dessous, nous avons créé une méthode dans l’interface, l’avons remplacée dans une classe et l’avons appelée avec succès. Voir l’exemple ci-dessous.
interface Eatable {
void eat(String choice);
}
public class SimpleTesting implements Eatable {
public void eat(String choice) {
System.out.println("I would like to eat - " + choice);
}
void buy(String item) {
System.out.println("Buy me a " + item);
}
public static void main(String[] args) {
SimpleTesting simpleTesting = new SimpleTesting();
simpleTesting.eat("Pizza");
simpleTesting.buy("Pizza");
simpleTesting.eat("Chicken");
simpleTesting.buy("Chicken");
}
}
Production :
I would like to eat - Pizza
Buy me a Pizza
I would like to eat - Chicken
Buy me a Chicken