Mot-clé protégé 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 :

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

1. Mot-clé par défaut : Ils sont accessibles uniquement à l'intérieur du package et ne peuvent pas être appelés en dehors de celui-ci. Comme son nom l'indique, il est automatiquement attribué par défaut lorsqu'aucun spécificateur d'accès n'est mentionné.
2. Mot-clé public : Ils sont accessibles depuis n'importe où dans le programme. Cela signifie qu'il peut être utilisé à partir de classes identiques ou différentes et du même package ou d'un package différent.
3. Mot-clé privé : Ils limitent les mots-clés à un niveau supérieur en ne permettant pas d'y accéder depuis n'importe où en dehors de la classe elle-même.
4. Mot-clé protégé : Dans cet article, nous en apprendrons davantage 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 :

• Dans la même classe dans laquelle il est déclaré.
• 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 forfait.

Les mots-clés protégés sont comme une combinaison de mots-clés publics et privés puisqu'ils ont été introduits pour accéder aux variables en dehors de la classe (ce qui n'est pas possible dans le cas de mots-clés privés) et maintiennent 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éfixé comme « 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.

Sortie :

 

Les mots-clés protégés ne peuvent être utilisés qu'au niveau du membre, c'est-à-dire les classes internes déclarées en dehors d'une fonction et non statiques. Le mot-clé protégé est différent de celui de privé car ils sont accessibles en dehors d'une classe et dans la sous-classe d'un autre package.

Certaines des restrictions concernant l'utilisation de mots-clés protégés sont :

• 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 comme protégées.
• L'accessibilité en dehors du forfait se fait uniquement par héritage.
• Un constructeur rendu protégé n'est pas accessible en dehors du package en créant son instance.

Exemples de mots-clés protégés en Java

Passons en revue quelques exemples où nous pouvons mieux comprendre le concept de mots-clés protégés.

1. Appeler un mot-clé protégé sans étendre la classe parent

Ici, nous essayons d'appeler le mot-clé de la classe parent 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é de 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);
}
}

Sortie :

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

Sortie :

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 nommée « Exemple ». 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 « Exemple1 ». Pour cela, il faut d'abord créer un objet de la classe parent « Exemple1 » puis imprimer la valeur attribué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);
}
}

Sortie :

4. Displaying protected keyword from a different package

Using the same code as above, we shall see how to call the protected keyword by creating a different package, “package2”. A protected keyword can be accessed only through inheritance from package1; hence “ProtectedExample2” is extended from “Example”. In a similar way as the first example, we have to create an object of the class “ProtectedExample2” in order to access the protected keyword from 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);
}
}

Output:

5. Accessing a protected class by overriding to sub-class

Here the class is declared as protected inside the inherited class “Example5”. Also, a protected class called “Example” is declared outside the function but in the same package. When an object of “Example5” is created and the protected class “disp()” is called, we can observe that the overridden method is called instead of the outside class. This is because we shall not be able to import “com.package1” and its class “Example” since it is not visible and causes a compilation error.

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

Output:

Importance of Protected Keyword

The importance of protected keyword in java is:

• These keywords allow the classes or their variables to be inherited from their parent class which is not possible with any other restricted keyword such as private.
• A protected keyword is the combination of a private keyword’s advantage and that of a public keyword. It eliminates the disadvantage of public keyword that the variable or class be accessible from anywhere in the program by restricting the scope.

Conclusion

As shown in the above examples, we choose protected keywords depending on the access level we require at the code level. They help greatly in cases where the same variable or class needs to be accessed from other inherited methods in the program. A parent-child relationship is always present between the parent class and its sub-classes which are using the protected keyword.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!