Masquage d'informations

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 12 sur 87.

La dissimulation d'informations est le principe consistant à restreindre l'accès direct aux données internes d'un objet. En combinant les champs private avec des getters et des setters, vous créez une barrière protectrice autour de l'état de votre objet.

Considérez ce qui se passe sans masquage d'informations :

public class Temperature {
    public double celsius;  // Exposé directement
}

// N'importe qui peut définir des valeurs invalides
Temperature t = new Temperature();
t.celsius = -500;  // En dessous du zéro absolu - impossible !

Avec le masquage d'informations, vous contrôlez la manière dont les données sont consultées et modifiées :

public class Temperature {
    private double celsius;
    
    public void setCelsius(double celsius) {
        if (celsius >= -273.15) {
            this.celsius = celsius;
        }
    }
    
    public double getCelsius() {
        return celsius;
    }
}

Désormais, les températures invalides sont rejetées automatiquement. La représentation interne est masquée — vous pourriez plus tard modifier la manière dont la température est stockée en interne (peut-être en Kelvin) sans affecter le code qui utilise la classe.

Cette approche offre trois avantages clés : la validation garantit l'intégrité des données, la flexibilité permet des modifications internes sans casser le code externe, et le contrôle vous permet de décider exactement quelles opérations sont autorisées sur vos données.

Défi

Facile

Construisons une classe de gestion Password qui démontre la dissimulation d'informations en protégeant les données sensibles et en appliquant des règles de sécurité via un accès contrôlé.

Vous allez créer deux fichiers pour organiser votre code :

Password.java : Créez une classe Password qui cache ses données internes et contrôle la manière dont les mots de passe peuvent être définis et consultés :
- Un champ privé password (String) qui stocke le mot de passe réel
- Un champ privé minLength (int) qui définit la longueur minimale acceptable du mot de passe
- Un constructeur qui prend en paramètre l'exigence de longueur minimale
- Un setter setPassword(String password) qui n'accepte que les mots de passe respectant la longueur minimale requise. S'il est valide, stockez-le et retournez true ; s'il est trop court, ne modifiez pas le mot de passe et retournez false
- Un getter getMaskedPassword() qui retourne le mot de passe avec tous les caractères remplacés par des astérisques (*) - n'exposez jamais le mot de passe réel !
- Une méthode checkPassword(String attempt) qui retourne true si la tentative correspond au mot de passe stocké, false sinon
- Un getter getLength() qui retourne la longueur du mot de passe actuel (ou 0 si aucun mot de passe n'est défini)
Main.java : Créez un objet Password avec une longueur minimale de 6, puis lisez deux entrées : un mot de passe à définir et une tentative à vérifier. Affichez trois lignes :
- Set: true ou Set: false (résultat de la définition du mot de passe)
- Masked: ****** (la version masquée du mot de passe)
- Match: true ou Match: false (résultat de la vérification de la tentative)

Vous recevrez deux entrées : le mot de passe à définir, et la tentative de mot de passe à vérifier.

Remarquez comment le mot de passe réel n'est jamais directement accessible depuis l'extérieur de la classe - c'est la dissimulation d'informations en action. La classe contrôle exactement quelles informations sont révélées et comment le mot de passe peut être modifié.

Aide-mémoire

La dissimulation d'informations (information hiding) restreint l'accès direct aux données internes d'un objet en utilisant des champs private combinés à des accesseurs (getters) et des mutateurs (setters).

Sans dissimulation d'informations, les champs sont exposés et peuvent être définis avec des valeurs invalides :

public class Temperature {
    public double celsius;  // Exposé directement
}

Temperature t = new Temperature();
t.celsius = -500;  // Valeur invalide autorisée

Avec la dissimulation d'informations, vous contrôlez l'accès et validez les données :

public class Temperature {
    private double celsius;
    
    public void setCelsius(double celsius) {
        if (celsius >= -273.15) {
            this.celsius = celsius;
        }
    }
    
    public double getCelsius() {
        return celsius;
    }
}

Principaux avantages de la dissimulation d'informations :

Validation : Assure l'intégrité des données en rejetant les valeurs invalides
Flexibilité : Permet des modifications internes sans affecter le code externe
Contrôle : Vous permet de décider quelles opérations sont autorisées sur vos données

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire le mot de passe à définir
        String passwordToSet = scanner.nextLine();
        // Lire la tentative de mot de passe à vérifier
        String passwordAttempt = scanner.nextLine();
        
        // TODO: Créer un objet Password avec une longueur minimale de 6
        
        // TODO: Définir le mot de passe et afficher le résultat ("Set: true" ou "Set: false")
        
        // TODO: Afficher le mot de passe masqué ("Masked: ******")
        
        // TODO: Vérifier la tentative de mot de passe et afficher le résultat ("Match: true" ou "Match: false")
        
    }
}