Modificateur d'accès Java 'protégé'

1. Vue d'ensemble

Dans le langage de programmation Java, les champs, les constructeurs, les méthodes et les classes peuvent être marqués avec des modificateurs d'accès. Dans ce didacticiel, nous examinerons l' accès protégé .

2. Le mot-clé protégé

Alors que les éléments déclarés comme privés ne sont accessibles que par la classe dans laquelle ils sont déclarés, le mot-clé protected autorise l'accès depuis les sous-classes et les membres du même package.

En utilisant le mot-clé protected , nous prenons des décisions sur les méthodes et les champs qui doivent être considérés comme internes d'un package ou d'une hiérarchie de classes, et lesquels sont exposés au code extérieur.

3. Déclaration des champs, méthodes et constructeurs protégés

Tout d'abord, créons unclasse nommée FirstClass contenant un champ, une méthode et un constructeur protégés :

public class FirstClass { protected String name; protected FirstClass(String name) { this.name = name; } protected String getName() { return name; } }

Avec cet exemple, en utilisant le mot-clé protected , nous avons accordé l'accès à ces champs aux classes du même package que FirstClass et aux sous-classes de FirstClass .

4. Accès aux champs, méthodes et constructeurs protégés

4.1 Du même paquet

Voyons maintenant comment accéder aux champs protégés en créant une nouvelle GenericClass déclarée dans le même package que FirstClass :

public class GenericClass { public static void main(String[] args) { FirstClass first = new FirstClass("random name"); System.out.println("FirstClass name is " + first.getName()); first.name = "new name"; } }

Comme cette classe appelante est dans le même package que FirstClass, elle est autorisée à voir et à interagir avec tous les champs, méthodes et constructeurs protégés .

4.2. À partir d'un autre package

Essayons maintenant d'interagir avec ces champs à partir d'une classe déclarée dans un package différent de FirstClass :

public class SecondGenericClass { public static void main(String[] args) { FirstClass first = new FirstClass("random name"); System.out.println("FirstClass name is "+ first.getName()); first.name = "new name"; } }

Comme nous pouvons le voir, nous obtenons des erreurs de compilation :

The constructor FirstClass(String) is not visible The method getName() from the type FirstClass is not visible The field FirstClass.name is not visible

C'est exactement ce à quoi nous nous attendions en utilisant le mot-clé protected . C'est parce que SecondGenericClass n'est pas dans le même package que FirstClass et ne le sous-classe pas.

4.3 À partir d'une sous-classe

Voyons maintenant ce qui se passe lorsque nous déclarons une classe étendant FirstClass mais déclarée dans un package différent :

public class SecondClass extends FirstClass { public SecondClass(String name) { super(name); System.out.println("SecondClass name is " + this.getName()); this.name = "new name"; } }

Comme prévu, nous pouvons accéder à tous les champs, méthodes et constructeurs protégés. En effet, SecondClass est une sous-classe de FirstClass .

5. classe intérieure protégée

Dans les exemples précédents, nous avons vu des champs protégés , des méthodes et des constructeurs en action. Il y a un autre cas particulier - une classe interne protégée .

Créons cette classe interne vide dans notre FirstClass :

package com.baeldung.core.modifiers; public class FirstClass { // ... protected static class InnerClass { } }

Comme nous pouvons le voir, il s'agit d'une classe interne statique et peut donc être construite à partir de l'extérieur d'une instance de FirstClass . Cependant, comme il est protégé , nous ne pouvons l'instancier qu'à partir du code dans le même package que FirstClass .

5.1 Du même paquet

Pour tester cela, éditons notre GenericClass :

public class GenericClass { public static void main(String[] args) { // ... FirstClass.InnerClass innerClass = new FirstClass.InnerClass(); } }

Comme nous pouvons le voir, nous pouvons instancier l' InnerClass sans aucun problème car GenericClass est dans le même package que FirstClass .

5.2. À partir d'un autre package

Essayons d'instancier une InnerClass à partir de notre SecondGenericClass qui, comme nous nous en souvenons, est en dehors du package FirstClass :

public class SecondGenericClass { public static void main(String[] args) { // ... FirstClass.InnerClass innerClass = new FirstClass.InnerClass(); } }

Comme prévu, nous obtenons une erreur de compilation :

The type FirstClass.InnerClass is not visible

5.3. Depuis une sous-classe

Essayons de faire la même chose depuis notre SecondClass :

public class SecondClass extends FirstClass { public SecondClass(String name) { // ... FirstClass.InnerClass innerClass = new FirstClass.InnerClass(); } }

Nous nous attendions à instancier facilement notre InnerClass . Cependant, nous obtenons également une erreur de compilation ici:

The constructor FirstClass.InnerClass() is not visible

Jetons un coup d'œil à notre déclaration InnerClass :

protected static class InnerClass { }

The main reason we are getting this error is that the default constructor of a protected class is implicitly protected. In addition, SecondClassis a sub-class of FirstClass but is not a sub-class of InnerClass. Finally, we also declaredSecondClass outside FirstClass' package.

For all these reasons, SecondClass can't access the protectedInnerClass constructor.

Si nous voulions résoudre ce problème et permettre à notre SecondClass d'instancier un objet InnerClass , nous pourrions déclarer explicitement un constructeur public :

protected static class InnerClass { public InnerClass() { } }

En faisant cela, nous n'obtenons plus d'erreur de compilation et nous pouvons maintenant instancier une InnerClass à partir de SecondClass .

6. Conclusion

Dans ce rapide didacticiel, nous avons abordé le modificateur d'accès protégé en Java. Avec lui, nous pouvons nous assurer d'exposer uniquement les données et méthodes requises aux sous-classes et classes du même package.

Comme toujours, l'exemple de code est disponible à l'adresse over sur GitHub.