Masquage de méthodes en Java

1. Implémentation du concept de masquage de méthode en Java
2. Différences entre le masquage et le remplacement de méthode en Java

Dans cet article, nous examinerons le concept de masquage de méthode en Java. Le masquage de méthode est similaire au remplacement, mais il entre en jeu lors de l’utilisation de la même signature de méthode pour les fonctions statiques dans les classes enfant et parent.

Implémentation du concept de masquage de méthode en Java

Dans l’exemple suivant, nous prenons trois classes, une classe Parent et Child avec la classe JavaExample avec la méthode main(). La classe Child hérite de la classe Parent. Les classes Parent et Child ont toutes deux deux méthodes.

Dans la classe Parent, nous avons une méthode appelée methodST() qui est une fonction static et renvoie une chaîne. La classe Child a également une methodST() avec le même type de retour et est statique ; seule la chaîne est modifiée.

Comme les deux méthodes sont statiques, nous pouvons l’appeler en utilisant les noms de la classe, et lorsque nous appelons la méthodeST() de la classe Parent, sa méthode est appelée et la chaîne est imprimée.

Mais quand on appelle la fonction methodST() de la classe Child, sa méthode est exécutée à la place de la classe Parent même si elle hérite de la classe Parent. Il s’appelle Method Hiding car l’enfant masque la méthode du parent.

Supposons que nous créons deux objets, un de la classe Parent et un autre de la classe Child. La méthode Parent est appelée uniquement parce que la référence est pour Parent, et les méthodes statiques sont attachées aux références des classes au lieu de leurs objets.

class Parent {
  public static String methodST() {
    return "methodST() of Parent class";
  }
}

class Child extends Parent {
  public static String methodST() {
    return "methodST() of Child class";
  }
}

public class JavaExample {
  public static void main(String[] args) {
    System.out.println("Parent.methodST(): " + Parent.methodST());
    System.out.println("Child.methodST(): " + Child.methodST());

    System.out.println();

    Parent parent = new Parent();
    Parent childParent = new Child();

    System.out.println("parent.methodST(): " + parent.methodST());
    System.out.println("childParent.methodST(): " + childParent.methodST());
  }
}

Production :

Parent.methodST(): methodST() of Parent class
Child.methodST(): methodST() of Child class

parent.methodST(): methodST() of Parent class
childParent.methodST(): methodST() of Parent class

Différences entre le masquage et le remplacement de méthode en Java

Nous avons besoin de méthodes statiques dans les classes parent et enfant pour le masquage de méthode tout en remplaçant les travaux avec des méthodes non statiques.

Lors du remplacement, les méthodes sont appelées à l’aide de l’objet d’exécution, tandis que le compilateur appelle les méthodes statiques à l’aide de la référence d’une classe dans le masquage de méthode.

Le masquage de méthode est également connu sous le nom de Early Binding, tandis que le remplacement est connu sous le nom de Late Binding.