Masquage de l’information

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 34 sur 110.

La dissimulation de l’information est le principe qui sous-tend l’encapsulation : l’idée qu’une classe doit dissimuler son fonctionnement interne et n’exposer que ce qui est nécessaire. Tu as appris les mécanismes (champs privés, accesseurs, mutateurs), mais le véritable objectif est de concevoir des classes faciles à utiliser et difficiles à mal utiliser.

Considérez une classe qui gère le mot de passe d'un utilisateur. Le stockage interne et la logique de hachage doivent être complètement cachés :

class UserAccount {
  String _username;
  String _passwordHash;
  
  UserAccount(this._username, String password) 
      : _passwordHash = _hashPassword(password);
  
  static String _hashPassword(String password) {
    return 'hashed_$password';  // Exemple simplifié
  }
  
  bool verifyPassword(String password) {
    return _passwordHash == _hashPassword(password);
  }
  
  String get username => _username;
}

Le code externe ne voit jamais le hachage du mot de passe et ne sait pas comment il est stocké. Il appelle simplement verifyPassword(). Cette séparation signifie que vous pourriez changer complètement l'algorithme de hachage sans affecter le code qui utilise cette classe.

L'idée clé est de penser à votre classe de l'extérieur vers l'intérieur.

Posez-vous la question : « De quoi une personne utilisant cette classe a-t-elle réellement besoin ? » N'exposez que cela, et gardez tout le reste privé. Cela crée une frontière claire entre ce que fait votre classe (son interface publique) et comment elle le fait (son implémentation privée).

Défi

Facile

Construisons un système de portefeuille sécurisé qui démontre le masquage des informations en pratique. Tu vas créer un portefeuille numérique qui gère le solde et l’historique des transactions d’un utilisateur, en gardant tous les détails internes sensibles complètement cachés du code externe.

Tu organiseras ton code en deux fichiers :

wallet.dart : crée une classe Wallet qui gère l’argent de manière sécurisée. Le portefeuille doit stocker publiquement le nom du propriétaire, mais tout le reste doit être masqué derrière une interface publique claire :
- Le solde interne et le journal des transactions doivent être privés : le code externe ne doit jamais voir comment tu stockes ou suis l’argent
- Une méthode privée doit gérer l’enregistrement interne des transactions (en stockant des entrées telles que "Deposit: $50.0" ou "Withdrawal: $30.0")
- Fournis une méthode publique deposit(double amount) qui ajoute de l’argent (uniquement si le montant est positif) et enregistre la transaction en interne
- Fournis une méthode publique withdraw(double amount) qui retire de l’argent uniquement si les fonds sont suffisants et si le montant est positif, en enregistrant la transaction en interne. Retourne true en cas de réussite et false sinon
- Fournis un getter public balance qui retourne le solde actuel (accès en lecture seule)
- Fournis une méthode publique getTransactionCount() qui retourne le nombre de transactions enregistrées (sans exposer la liste réelle des transactions)
- Fournis une méthode publique getLastTransaction() qui retourne la chaîne de caractères de la transaction la plus récente, ou "No transactions" s’il n’y en a aucune
- Inclus une méthode printSummary() qui affiche l’état du portefeuille
main.dart : importe ton portefeuille et montre comment le masquage des informations crée une interface claire et sûre :
- Crée un portefeuille pour le propriétaire "Sarah"
- Dépose 100.0
- Dépose 50.0
- Essaie de retirer 200.0 et affiche "Withdrawal of 200.0: [success/failed]" selon le résultat
- Retire 30.0 et affiche "Withdrawal of 30.0: [success/failed]"
- Appelle printSummary()
- Affiche "Transaction count: [count]"
- Affiche "Last transaction: [transaction]"

La méthode printSummary() doit afficher :

=== Wallet Summary ===
Owner: [ownerName]
Balance: $[balance]

Remarque comment le code externe peut interagir avec le portefeuille au moyen de méthodes claires et ciblées, sans jamais savoir comment le solde est stocké ni comment les transactions sont suivies en interne. Les détails d’implémentation sont complètement masqués : tu pourrais modifier la manière dont les transactions sont stockées sans affecter le code qui utilise le portefeuille.

Sortie attendue :

Withdrawal of 200.0: failed
Withdrawal of 30.0: success
=== Wallet Summary ===
Owner: Sarah
Balance: $120.0
Transaction count: 3
Last transaction: Withdrawal: $30.0

Essayez vous-même

import 'wallet.dart';

void main() {
  // TODO: Créer un portefeuille pour le propriétaire "Sarah"
  
  // TODO: Déposer 100.0
  
  // TODO: Déposer 50.0
  
  // TODO: Tenter de retirer 200.0 et afficher le résultat
  // Format : "Withdrawal of 200.0: [success/failed]"
  
  // TODO: Retirer 30.0 et afficher le résultat
  // Format : "Withdrawal of 30.0: [success/failed]"
  
  // TODO: Appeler printSummary()
  
  // TODO: Afficher le nombre de transactions
  // Format : "Transaction count: [count]"
  
  // TODO: Afficher la dernière transaction
  // Format : "Last transaction: [transaction]"
}