mot-clé protégé en Java

Le mot-clé protected en Java est un modificateur d'accès utilisé pour les variables membres et les méthodes. Il fournit un niveau de contrôle d'accès qui permet l'accès au sein d'un même paquet et par des sous-classes, même si elles se trouvent dans des paquets différents.

Utilisation

Le modificateur d'accès protected est utilisé pour restreindre l'accès aux membres d'une classe de manière à ce qu'ils soient accessibles dans leur propre paquetage et par les sous-classes. Cette fonction est particulièrement utile pour créer une structure d'héritage contrôlée.

Syntax

protected dataType variableName;
protected returnType methodName() {
    // method body
}

• dataType: Le type de la variable.
• variableName: Le nom de la variable.
• returnType: Le type de retour de la méthode.
• methodName: Le nom de la méthode.

Exemples

Exemple 1 : Variable protégée

package com.example;

public class Parent {
    protected int protectedVariable = 100;
}

package com.example;

public class Child extends Parent {
    public void display() {
        System.out.println("Protected Variable: " + protectedVariable);
    }
}

Dans cet exemple, protectedVariable est déclaré avec le mot-clé protected dans la classe Parent. La classe Child, qui est une sous-classe de Parent, peut accéder à protectedVariable et imprimer sa valeur.

Exemple 2 : Méthode protégée

package com.example;

public class Parent {
    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

package com.example;

public class Child extends Parent {
    public void callProtectedMethod() {
        protectedMethod();
    }
}

Ici, protectedMethod est une méthode protégée dans la classe Parent. La classe Child peut appeler cette méthode car elle est une sous-classe de Parent.

Exemple 3 : L'accès dans différents paquets

package com.example.parent;

public class Parent {
    protected void protectedMethod() {
        System.out.println("Protected method in Parent class.");
    }
}

package com.example.child;

import com.example.parent.Parent;

public class Child extends Parent {
    public void callProtectedMethod() {
        protectedMethod();
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.callProtectedMethod();
    }
}

Dans cet exemple, la classe Parent se trouve dans le paquetage com.example.parent et la classe Child dans le paquetage com.example.child. La classe Child peut toujours accéder à la classe protectedMethod de la classe Parent car il s'agit d'une sous-classe.

Conseils et bonnes pratiques

• Héritage contrôlé: Utilisez protected pour permettre aux sous-classes d'accéder aux membres tout en les cachant aux autres classes dans des paquets différents.
• Accès au paquet: N'oubliez pas que les membres de protected sont également accessibles aux autres classes du même paquet.
• Encapsulation: Utilisez protected pour équilibrer l'encapsulation et l'héritage, en n'exposant que les membres nécessaires aux sous-classes.
• Évitez la surexposition: Veillez à ne pas abuser de protected, car cela pourrait exposer trop de détails sur le fonctionnement interne de la classe aux sous-classes et aux autres classes du même paquetage.
• Documentation: Documentez clairement l'utilisation prévue des membres protégés afin d'éviter toute utilisation abusive ou tout accès involontaire.
• Accès par le biais d'instances de sous-classes: Comprenez que les membres protégés sont accessibles par l'intermédiaire des instances des sous-classes, même si l'instance est déclarée dans un paquetage différent.