TOC

Variable et méthode masquées en Java

Variable et méthode cachées en Java

1. introduction

Dans ce didacticiel,we’re going to learn about variable and method hiding in the Java language.

Premièrement, nous comprendrons le concept et l’objectif 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 variables 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 étendues 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 méthodes, constructeurs, dans n'importe quel bloc de code avec des accolades

  • variables d'instance - définies à l'intérieur d'une classe et appartenant à l'instance de l'objet

  • variables de classe oustatic - sont déclarées dans la classe avec le mot-cléstatic. Ils ont une portée de niveau de classe.

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

2.1. Le pouvoir du local

Jetons un œil à la classeHideVariable: 

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 variablemessage variable déclarée à 4 endroits différents. Les variables locales déclarées à l'intérieur du constructeur et les deux méthodes observent 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 depuis la portée locale, nous pouvons utiliser le mot-cléthis comme il est montré dans la méthodeprintInstanceVariable().

2.2. Se cacher et la hiérarchie

De même, lorsque les classes enfant et parent ont une variable du 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. Une avec la classe parent et une autre avec l'enfant, puis invoquez les méthodesprintInstanceVariable() sur chacune d'elles: 

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

parentVariable.printInstanceVariable();
childVariable.printInstanceVariable();

La sortie affiche la propriété qui se cache: 

parent variable
child variable

In most cases, we should avoid creating variables with the same name both in parent and child classes. Au lieu de cela, nous devrions utiliser un modificateur d'accès approprié commeprivate and fournir des méthodes getter / setter à cette fin.

3. Masquage de méthode

La méthode peut être masquée 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, alors la méthode enfanthidesest celle de la classe parent. Pour en savoir plus sur le mot cléstatic,this write-up is a good place to start.

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

Voyons maintenant cet exemple pratique: 

public class BaseMethodClass {

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

BaseMethodClass a une seule méthodeprintMessage() static.

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");
    }
}

Voilà comment cela fonctionne: 

ChildMethodClass.printMessage();

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

child static method

LeChildMethodClass.printMessage() décale la méthode enBaseMethodClass.

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 supporte les liaisons tardives, la méthode à appeler est donc déterminée au moment de l'exécution.

On the other hand, method hiding works with static ones. Therefore it’s determined at compile time.

4. Conclusion

In this article, we went over the concept of method and variable hiding in Java. Nous avons montré différents scénarios de masquage et d’observation variables. Le point culminant de l’article est également la comparaison entre la méthode prioritaire et la méthode masquée.

Comme d'habitude, le code complet est disponibleover on GitHub.

Related