Liaison dynamique en Java

« Dynamique » signifie « temps d'exécution » et « liaison » signifie « association ». Ainsi, le terme liaison dynamique indique une association d'objets au moment de l'exécution par une machine virtuelle Java. Nous verrons ici comment Java réalise une liaison dynamique au moment de l'exécution, c'est-à-dire avant l'exécution finale du code mais après la compilation.

Syntaxe : Pour la liaison dynamique en Java, vous devez suivre la syntaxe de base de Java avec des annotations. Vous pouvez utiliser l'annotation @Override ici pour indiquer quelle méthode nous souhaitons remplacer spécifiquement.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Comment fonctionne la liaison dynamique en Java ?

Le polymorphisme d'exécution fonctionne en Java par remplacement de méthode. Le remplacement de méthode se produit lorsque les objets ont le même nom de méthode, les mêmes arguments et le même type que leur classe parent mais avec des fonctionnalités différentes. Si une classe enfant contient ce type de méthode, nous l’appelons une méthode surchargée.

Pourquoi est-ce appelé liaison dynamique ?

La raison étant nommée ainsi, car la fonctionnalité de la méthode est décidée dynamiquement au moment de l'exécution en fonction de l'objet par JVM. Il est également appelé « polymorphisme d’exécution ». lorsque nous appelons une méthode surchargée d'une classe enfant via sa référence de type parent (ce phénomène en Java est appelé « Upcasting »), alors le type de l'objet indique quelle méthode ou fonctionnalité sera invoquée. La prise de cette décision se produit pendant l'exécution par JVM après la compilation du code. C’est pourquoi on parle de polymorphisme d’exécution. On l'appelle également « liaison tardive », car la liaison de la méthode et de l'objet, c'est-à-dire la fonctionnalité de la méthode de l'objet qui sera affichée, est décidée tardivement, c'est-à-dire après la compilation.

Règles concernant la liaison dynamique

• Les méthodes ou fonctions des classes enfant et parent doivent avoir le même nom.
• Les méthodes ou fonctions des classes enfant et parent doivent avoir le même paramètre.
• La relation successorale est obligatoire (relation IS-A).

Limitations de la liaison dynamique

• Vous ne pouvez pas remplacer les méthodes privées d'une classe parent.
• Vous ne pouvez pas remplacer les méthodes Final.
• Vous ne pouvez pas remplacer les méthodes statiques.

Exemples d'implémentation de la liaison dynamique

Nous discuterons ici de quelques exemples de code de liaison dynamique :

Exemple n°1

Dans cet exemple, nous allons montrer comment la méthode Locate() affiche différents messages selon le type d'objet auquel elle est associée. Lorsqu'il est associé au type « Continent », il affiche les messages d'une classe parent. Lorsqu'il est associé au type « SubContinent », il affiche les messages de la classe enfant.

Code :

class Continent {
public void locate () {
System.out.println("We are in Continent");
}
}
class SubContinent extends Continent {
@Override
public void locate () {
System.out.println("We are in SubContinent");
}
}
public class DynamicBinding {
public static void main(String args[]) {
Continent superObject = new Continent ();
superObject.locate(); //method of super class or parent class is called
SubContinent subObject = new SubContinent (); // upcasting
subObject.locate();//method of sub class or child class is called by Parent reference, this is called "Dynamic Binding"
SubContinent subObject2 = new SubContinent ();
subObject2.locate(); //method of sub class or child class is called
}
}

Sortie :

Exemple n°2

Prenons un exemple de liaison dynamique dans le cas d'un héritage multiniveau. Dans cet exemple, deux niveaux d'héritage sont pris en compte. Dans cet exemple, nous allons montrer comment la méthode identifie () affiche différents messages selon le type d'objet auquel elle est associée. Lorsqu'il est associé au type « Ordinateur », il affiche les messages d'une classe parent. Lorsqu'il est associé au type « Desktop », il affiche les messages de sa classe enfant. Toujours au deuxième niveau d'héritage, lorsqu'il est associé au type « Laptop », il affiche les messages de sa classe enfant de son parent, la classe « Desktop ».

Code :

class Computer {
void identify() {
System.out.println("This is Computer");
}
}
class Desktop extends Computer {
void identify (){
System.out.println("This is Desktop");
}
}
class Laptop extends Desktop {
void identify (){
System.out.println("This is Laptop");
}
}
public class DynamicBinding {
public static void main(String args[]){
Computer superObject=new Computer ();
Computer subObject=new Desktop (); // // upcasting : first level of heritance
Computer babyObject=new Laptop (); // // upcasting : second level of heritance
superObject.identify ();
subObject.identify (); //run time polymorphism happening in first level of heritance
babyObject.identify (); //run time polymorphism happening in second level of heritance
}
}

Sortie :

Exemple #3

Prenons un autre exemple de polymorphisme d'exécution dans le cas d'un héritage multiniveau. Dans cet exemple, trois niveaux d'héritage sont pris en compte. Dans cet exemple, nous allons montrer comment la méthode feature() affiche différentes fonctionnalités en fonction du type d'objet auquel elle est associée. Lorsqu'il est associé au type « Cosmétique », il affiche les messages d'une classe parent. Lorsqu'il est associé au type « Parfum », il affiche les messages de sa classe enfant. Toujours au deuxième niveau d'héritage, lorsqu'il est associé au type « Deo », il affiche les messages de sa classe enfant de son parent, la classe « Parfum ». Toujours au troisième niveau d'héritage, lorsqu'il est associé au type « DeoStick », il affiche les messages de sa classe enfant de son parent, la classe « Deo ».

Code :

class Cosmetics{
void feature() {
System.out.println("Cosmetics are expensive");
}
}
class Perfume extends Cosmetics {
void feature(){
System.out.println("Perfume is soothing");
}
}
class Deo extends Cosmetics {
void feature(){
System.out.println("Deo is sometimes better than perfume");
}
}
class DeoStick extends Deo{
void feature(){
System.out.println("DeoStick is very handy");
}
}
public class RunTimePolymorphism {
public static void main(String args[]){
Cosmetics superObject=new Cosmetics ();
Cosmetics subObject=new Perfume(); // child object type : first level of heritance
Cosmetics sub2Object=new Deo(); // child object type : second level of heritance
Cosmetics sub3Object=new DeoStick(); // child object type : third level of heritance
superObject.feature();
subObject.feature(); //run time polymorphism happening in first level of heritance
sub2Object.feature(); //run time polymorphism happening in second level of heritance
sub3Object.feature(); //run time polymorphism happening in third level of heritance
}
}

Sortie :

Conclusion

Ceci conclut notre apprentissage du sujet « Liaison dynamique en Java ». Écrivez-vous les codes mentionnés dans les exemples ci-dessus dans le compilateur Java et vérifiez le résultat. L'apprentissage des codes sera incomplet si vous n'écrivez pas le code par vous-même.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!