Masquage de variables et de méthodes en Java

1. Introduction

Dans ce tutoriel, nous allons en apprendre davantage sur le masquage de variables et de méthodes dans le langage Java .

Tout d'abord, nous comprendrons le concept et le but de chacun de ces scénarios. Après cela, nous plongerons dans les cas d'utilisation et examinerons différents exemples.

2. Masquage variable

Le masquage de variable se produit lorsque nous déclarons une propriété dans une portée locale qui porte le même nom que celui que nous avons déjà dans la portée externe.

Avant de passer aux exemples, récapitulons brièvement les portées de variables possibles en Java. Nous pouvons les définir avec les catégories suivantes:

  • variables locales - déclarées dans un morceau de code tel que des méthodes, des constructeurs, dans n'importe quel bloc de code avec des accolades
  • variables d'instance - définies à l'intérieur d'une classe et appartiennent à l'instance de l'objet
  • classe ou variables statiques - sont déclarées dans la classe avec le mot-clé static . Ils ont une portée au niveau de la classe.

Maintenant, décrivons le masquage avec des exemples, pour chaque catégorie individuelle de variables.

2.1. Le pouvoir du local

Jetons un coup d'œil à la classe HideVariable :

public class HideVariable { private String message = "this is instance variable"; HideVariable() { String message = "constructor local variable"; System.out.println(message); } public void printLocalVariable() { String message = "method local variable"; System.out.println(message); } public void printInstanceVariable() { String message = "method local variable"; System.out.println(this.message); } }

Ici, nous avons la variable de message déclarée à 4 endroits différents. Les variables locales déclarées à l'intérieur du constructeur et les deux méthodes occultent la variable d'instance.

Testons l'initialisation d'un objet et appelons les méthodes:

HideVariable variable = new HideVariable(); variable.printLocalVariable(); variable.printInstanceVariable();

La sortie du code ci-dessus est:

constructor local variable method local variable this is instance variable

Ici, les 2 premiers appels récupèrent les variables locales.

Pour accéder à la variable d'instance à partir de la portée locale, nous pouvons utiliser ce mot - clé comme indiqué dans la méthode printInstanceVariable () .

2.2. Se cacher et la hiérarchie

De même, lorsque les classes enfant et parent ont une variable avec le même nom, la variable enfant masque celle du parent.

Supposons que nous ayons la classe parente:

public class ParentVariable { String instanceVariable = "parent variable"; public void printInstanceVariable() { System.out.println(instanceVariable); } }

Après cela, nous définissons une classe enfant:

public class ChildVariable extends ParentVariable { String instanceVariable = "child variable"; public void printInstanceVariable() { System.out.println(instanceVariable); } }

Pour le tester, initialisons deux instances. Un avec la classe parent et un autre avec l'enfant, puis invoquez les méthodes printInstanceVariable () sur chacun d'eux:

ParentVariable parentVariable = new ParentVariable(); ParentVariable childVariable = new ChildVariable(); parentVariable.printInstanceVariable(); childVariable.printInstanceVariable();

La sortie montre la propriété masquant:

parent variable child variable

Dans la plupart des cas, nous devons éviter de créer des variables portant le même nom dans les classes parent et enfant . Au lieu de cela, nous devrions utiliser un modificateur d'accès approprié comme private et fournir des méthodes getter / setter à cette fin.

3. Méthode de masquage

Le masquage de méthode peut se produire dans n'importe quelle structure hiérarchique de java. Lorsqu'une classe enfant définit une méthode statique avec la même signature qu'une méthode statique dans la classe parent, la méthode enfant masque celle de la classe parent. Pour en savoir plus sur le mot-clé static , cet article est un bon point de départ.

Le même comportement impliquant les méthodes d'instance est appelé remplacement de méthode. Pour en savoir plus sur le remplacement de méthode, consultez notre guide ici.

Maintenant, jetons un œil à cet exemple pratique:

public class BaseMethodClass { public static void printMessage() { System.out.println("base static method"); } }

BaseMethodClass a une seule méthode statique printMessage () .

Ensuite, créons une classe enfant avec la même signature que dans la classe de base:

public class ChildMethodClass extends BaseMethodClass { public static void printMessage() { System.out.println("child static method"); } }

Voici comment ça fonctionne:

ChildMethodClass.printMessage();

La sortie après avoir appelé la méthode printMessage () :

child static method

Le ChildMethodClass.printMessage () cache le procédé BaseMethodClass .

3.1. Masquage de méthode vs remplacement

Le masquage ne fonctionne pas comme le remplacement, car les méthodes statiques ne sont pas polymorphes. Le remplacement se produit uniquement avec les méthodes d'instance. Il prend en charge la liaison tardive, donc la méthode qui sera appelée est déterminée au moment de l'exécution.

D'autre part, le masquage de méthode fonctionne avec des méthodes statiques. Par conséquent, il est déterminé au moment de la compilation .

4. Conclusion

Dans cet article, nous avons passé en revue le concept de masquage de méthode et de variable en Java . Nous avons montré différents scénarios de masquage et d'ombrage variables. Le point fort important de l'article est également de comparer le remplacement et le masquage de la méthode.

Comme d'habitude, le code complet est disponible sur sur GitHub.