Modificateur Privé

Comment masquer les champs et les méthodes d'une autre classe ?

Les modificateurs d'accès sont utilisés pour contrôler la visibilité et l'accessibilité des variables et des méthodes en Java. Ils nous permettent de définir la portée et de restreindre l'accès à certains membres d'une classe.

Nous avons déjà discuté des modificateurs d'accès dans la section précédente. Maintenant, examinons de plus près le modificateur d'accès le plus couramment utilisé - private.

Comme vous le savez, avec le modificateur d'accès private, nous ne pouvons accéder à un champ/méthode que depuis la classe dans laquelle il se trouve. Voyons un exemple d'utilisation du modificateur private :

Par exemple, si nous ne voulons pas qu'une variable dans une classe soit visible ou accessible à une autre classe, nous pouvons utiliser le modificateur d'accès private:

Main


              123456789101112131415
            
package com.example;

public class Main {
    public static void main(String[] args) {
        Person bob = new Person();
        bob.name = "Bob";
        System.out.println(bob.name);
    }
}

class Person {
    private String name;
    private int age;
    private String gender;
}

Nous avons déclaré les champs de la classe Person comme private. Lorsque nous essayons d'initialiser directement le champ, nous obtenons une erreur indiquant que le champ name a un modificateur d'accès private et n'est pas accessible pour l'appel ou la modification dans la méthode principale.

Comment initialiser un champ privé ?

La manière la plus simple de contourner la protection est d'utiliser l'initialisation via un constructeur. Cependant, de cette manière, nous ne pouvons qu'initialiser les champs des objets mais pas accéder à ces champs. Regardons un exemple :

Main


              123456789101112131415161718
            
package com.example;

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob");
        System.out.println(bob.name);
    }
}

class Person {
    private String name;
    private int age;
    private String gender;

    public Person(String name) {
        this.name = name;
    }
}

Nous avons pu initialiser le champ name via le constructeur, mais nous ne pouvons toujours pas accéder à ce champ et l'imprimer en utilisant System.out.println(). Pour contourner cela, nous pouvons surcharger la méthode toString() afin que lorsque nous appelons System.out.println(bob);, il affiche des informations sur ses champs. Regardons un exemple :

Main


              1234567891011121314151617181920212223
            
package com.example;

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob");
        System.out.println(bob);
    }
}

class Person {
    private String name;
    private int age;
    private String gender;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + '}';
    }
}

Nous avons finalement réussi à afficher la valeur du champ name de l'objet bob. Nous avons réalisé cela en utilisant la méthode redéfinie toString(), où nous avons implémenté la logique pour afficher le name.

La question se pose, pourquoi avons-nous besoin de ce modificateur d'accès si nous devons écrire autant de code supplémentaire ?

Parfois, dans différentes classes, il y a des variables avec le même nom, et dans de tels cas, il est nécessaire de cacher les variables de ces classes afin que d'autres classes n'aient pas accès à des champs inutiles. Cela améliore grandement la commodité d'écriture du code en général lorsque vous comprenez à quel champ appartient quelle classe.

Tout était clair ?

Merci pour vos commentaires !

Section 5. Chapitre 3