Présentation des mots clés protégés en Java
Les mots clés protégés sont des mots clés utilisés pour restreindre la portée dans laquelle la variable, la méthode et les constructeurs sont accessibles. C'est l'un des types de modificateurs d'accès en Java. Ils sont utilisés pour différencier la portée des méthodes, des variables, des constructeurs et des classes. Il existe 4 types de modificateurs d'accès en Java et ce sont:
- Mot clé par défaut: ils ne sont accessibles que dans le package et ne peuvent pas être appelés en dehors. Comme son nom l'indique, quand aucun spécificateur d'accès n'est mentionné, il est automatiquement attribué par défaut.
- Mot-clé public: ils sont accessibles de n'importe où dans le programme. Cela signifie qu'il peut être utilisé à partir de la même classe ou d'une classe différente et du même package ou d'un package différent.
- Mot-clé privé: ils restreignent les mots-clés à un niveau supérieur en ne leur permettant pas d'accéder de n'importe où en dehors de la classe elle-même.
- Mot-clé protégé: dans cet article, nous allons en savoir plus sur les mots-clés protégés.
Une fois qu'une variable ou une méthode est marquée comme protégée, elle n'est accessible que par les méthodes ci-dessous:
- À l'intérieur de la même classe dans laquelle il est déclaré.
- À partir d'autres classes qui sont également dans le même package que la classe déclarée.
- Classes héritées de celle déclarée, quel que soit leur package.
Les mots-clés protégés sont comme une combinaison de mots-clés publics et privés, car ils ont été introduits pour pouvoir accéder aux variables en dehors de la classe (ce qui n'est pas possible dans le cas de mots-clés privés) mais aussi en maintenant que seules certaines méthodes peuvent en hériter.
Syntaxe
Les mots clés protégés sont déclarés avec le mot clé précédé de "protégé". Nous déclarons d'abord le mot-clé protégé dans l'une des classes appelées «MyClass» comme ci-dessous:
class MyClass (
protected String name = "Katy";
protected int token= 55;
)
public class SubClass extends MyClass (
public static void main(String() args) (
SubClass obj = new SubClass();
System.out.println(obj.name + "'s token number is: " + obj.token);
)
)
Ici, la classe "SubClass" étend "MyClass" et donc le mot-clé protégé peut être utilisé ici en créant un objet de SubClass et en appelant les variables.
Production:
Les mots clés protégés ne peuvent être utilisés qu'au niveau des membres, c'est-à-dire des classes internes qui sont déclarées en dehors d'une fonction et qui ne sont pas statiques. Les mots clés protégés sont différents de ceux de private car ils sont accessibles en dehors d'une classe et dans la sous-classe d'un autre package.
Certaines des restrictions sur l'utilisation de mots clés protégés sont les suivantes:
- Ils ne peuvent pas être utilisés pour déclarer des classes comme protégées.
- Les interfaces ne peuvent pas être déclarées protégées.
- L'accessibilité en dehors du package se fait uniquement par héritage.
- Un constructeur qui est rendu protégé n'est pas accessible en dehors du package en créant son instance.
Exemples
Passons en revue quelques exemples où nous pouvons mieux comprendre le concept de mots clés protégés.
1. Appel de mot-clé protégé sans étendre la classe parent
Ici, nous essayons d'appeler le mot-clé de la classe parente de "package1". "ProtectedExample2" est créé dans "package2" et le mot-clé "disp" est appelé ici. Mais le code ne pourra pas accéder au mot-clé puisque la classe enfant n'a pas hérité sa valeur de la classe principale et lèvera une exception comme indiqué.
Code:
package com.package1;
public class Example (
protected String disp="Printing message from protected variable from package1";
)
//Create new package as com.package2
//Create new class as ProtectedExample2
package com.package2;
import com.package1.Example;
public class ProtectedExample2 (
public static void main(String() args) (
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
)
)
Production:
2. Accéder à une classe protégée
Dans cet exemple, nous essayons d'accéder à la classe «ProtectedExample5» qui est protégée. Cela provoque une erreur de compilation.
Code:
protected class ProtectedExample5 (
void display()
(
System.out.println("Try to access outer protected class");
)
public static void main(String() args) (
ProtectedExample5 p=new ProtectedExample5();
p.display();
)
)
Production:
3. Affichage du mot clé protégé du même package mais d'une classe différente
Dans l'exemple ci-dessous, nous créons d'abord un package appelé «com.package1» et créons une nouvelle classe avec le nom «Example». Ici, nous déclarons que notre mot-clé «disp» est protégé. Nous allons essayer d'afficher ce mot-clé protégé en utilisant la classe "Example1". Pour cela, un objet de classe parent "Example1" doit d'abord être créé puis imprimer la valeur affectée au mot-clé "disp".
Code:
package com.package1;
public class Example (
protected String disp="Printing message from protected variable from package1";
)
class Example1 (
public static void main(String() args) (
Example obj=new Example();
System.out.println(obj.disp);
)
)
Production:
4. Affichage du mot-clé protégé d'un autre package
En utilisant le même code que ci-dessus, nous verrons comment appeler le mot-clé protégé en créant un package différent "package2". Un mot-clé protégé n'est accessible que par héritage de package1, d'où «ProtectedExample2» est étendu de «Example». De la même manière que le premier exemple, nous devons créer un objet de la classe "ProtectedExample2" afin d'accéder au mot-clé protégé du package "com.package1".
Code:
package com.package2;
import com.package1.Example;
public class ProtectedExample2 extends Example(
public static void main(String() args) (
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
)
)
Production:
5. Accéder à une classe protégée en remplaçant la sous-classe
Ici, la classe est déclarée protégée à l'intérieur de la classe héritée «Example5». De plus, une classe protégée appelée «Example» est déclarée en dehors de la fonction mais dans le même package. Lorsqu'un objet de «Example5» est créé et que la classe protégée «disp ()» est appelée, nous pouvons observer que la méthode surchargée est appelée à la place de la classe externe. En effet, nous ne pourrons pas importer "com.package1" et sa classe "Example" car il n'est pas visible et provoque une erreur de compilation.
Code:
//Create a file by Example.java
package com.package1;
class Example
(
protected void disp()
(
System.out.println("Printing from protected class in the outside function");
)
)
//Create a class by the name Example5.java
public class Example5 extends Example (
protected void disp()
(
System.out.println("Accessing the overriden function");
)
public static void main(String() args) (
Example5 exp=new Example5();
exp.disp();
)
)
Production:
Importance du mot clé protégé
- Ces mots clés permettent aux classes ou à leurs variables d'être héritées de sa classe parente, ce qui n'est pas possible avec tout autre mot clé restreint tel que private.
- Le mot clé protégé est la combinaison de l'avantage d'un mot clé privé et de celui d'un mot clé public. Il élimine l'inconvénient du mot clé public que la variable ou la classe soit accessible de n'importe où dans le programme en restreignant la portée.
Conclusion - Mot clé protégé en Java
Comme indiqué dans les exemples ci-dessus, nous choisissons des mots clés protégés en fonction du niveau d'accès dont nous avons besoin au niveau du code. Ils aident grandement dans les cas où la même variable ou classe doit être accessible à partir d'autres méthodes héritées du programme. Une relation parent-enfant est toujours présente entre la classe parent et ses sous-classes qui utilisent le mot-clé protégé.
Articles recommandés
Ceci est un guide des mots clés protégés en Java. Ici, nous discutons de l'aperçu, de la syntaxe et des différents exemples de mots clés protégés en java. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Encapsulation en Java
- Constructeur en Java
- Questions d'entretiens chez Java
- Remplacement dans les POO
- Mots-clés Java
- Outils de déploiement Java
- Modificateurs d'accès en PHP
- Surcharge en Java
- Encapsulation en JavaScript