Qu'est-ce que l'encapsulation ?
L'encapsulation en Java consiste à garder cachés les détails du fonctionnement de quelque chose tout en permettant aux autres de l'utiliser. Vous regroupez vos données (comme les variables) et vos méthodes (comme les fonctions) en une seule unité, appelée classe. Au lieu de permettre à tout le monde d'accéder directement à vos données, vous fournissez des méthodes (getters et setters) pour contrôler la manière dont elles sont consultées ou modifiées. De cette façon, vous protégez vos données et gardez votre code propre et organisé, sans laisser personne perturber le fonctionnement interne à moins que vous ne le souhaitiez.

Comment l'utiliser
Pour utiliser l'encapsulation en Java, vous créez une classe avec des champs privés et fournissez des méthodes publiques (telles que des getters et des setters) pour accéder et modifier ces champs. Cela garantit que les données ne peuvent être modifiées que de manière contrôlée. Par exemple, si vous souhaitez créer une classe Person dont le nom et l'âge sont privés, vous utiliserez des getters pour récupérer les valeurs et des setters pour les mettre à jour. Voici comment procéder :

public class Person {
    // Private fields
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age
    public void setAge(int age) {
        if(age > 0) { // Simple validation
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }
}

// Using the Person class
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);

        // Accessing fields using getters
        System.out.println(person.getName()); // Output: John
        System.out.println(person.getAge());  // Output: 25

        // Modifying fields using setters
        person.setName("Jane");
        person.setAge(30);

        System.out.println(person.getName()); // Output: Jane
        System.out.println(person.getAge());  // Output: 30
    }
}

Décomposons-le
Décomposons le code et expliquons chaque section étape par étape :

1. Définition de classe avec des champs privés

public class Person {
    // Private fields
    private String name;
    private int age;
}

Explication:

Il s'agit de la classe Person où nous définissons deux champs privés : name (une chaîne) et age (un int). En rendant ces champs privés, nous garantissons qu'aucune autre classe ne peut y accéder ou les modifier directement. C'est l'idée centrale de l'encapsulation : cacher l'état interne d'un objet.

2. Constructeur

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

Explication:

Le constructeur initialise l'objet Person lors de sa création. Il prend deux paramètres, le nom et l'âge, et attribue ces valeurs aux champs privés. Cela garantit que lorsqu'un nouvel objet Personne est créé, il démarre avec des données valides.

3. Getter et Setter pour

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

Explication:

Le constructeur initialise l'objet Person lors de sa création. Il prend deux paramètres, le nom et l'âge, et attribue ces valeurs aux champs privés. Cela garantit que lorsqu'un nouvel objet Personne est créé, il démarre avec des données valides.

4. Getter et Setter pour l'âge (avec validation)

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age
    public void setAge(int age) {
        if (age > 0) { // Simple validation
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }

Explication:

Le getter getAge() fonctionne de la même manière que celui de name, permettant d'accéder au champ age.
Le setter setAge() permet non seulement de modifier le champ age mais ajoute également un contrôle de validation. La condition if garantit que l'âge n'est défini que s'il s'agit d'un nombre positif. Si un âge invalide est fourni (comme un nombre négatif), le setter empêche la mise à jour et imprime un message à la place. Ceci est un exemple de la façon dont l'encapsulation vous permet de contrôler le type de données qui peuvent être définies.

5. Utilisation de la classe Personne

// Using the Person class
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);

        // Accessing fields using getters
        System.out.println(person.getName()); // Output: John
        System.out.println(person.getAge());  // Output: 25

        // Modifying fields using setters
        person.setName("Jane");
        person.setAge(30);

        System.out.println(person.getName()); // Output: Jane
        System.out.println(person.getAge());  // Output: 30
    }
}

Explication:

Dans cette section, nous créons un objet Person (person) à l'aide du constructeur. Le constructeur définit le nom initial sur "John" et l'âge sur 25 ans.

Ensuite, nous utilisons les getters (getName() et getAge()) pour imprimer les valeurs de nom et d'âge. Après cela, nous utilisons les setters (setName() et setAge()) pour mettre à jour les valeurs. Enfin, les valeurs mises à jour sont à nouveau imprimées à l'aide des getters.

Points clés de l'encapsulation en action :

• Protection des données :

  Les champs privés ne sont pas directement accessibles ou modifiables depuis l'extérieur de la classe.

• Accès contrôlé :

  Les getters et setters fournissent un moyen contrôlé d'accéder et de modifier les champs privés.

• Validation:

  Le paramètre d'âge montre comment vous pouvez appliquer des règles (par exemple, l'âge doit être positif) pour protéger les données contre les entrées non valides.