Masquage d'informations

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

Le masquage d'information est le principe derrière l'encapsulation - l'idée qu'une classe doit masquer son fonctionnement interne et n'exposer que ce qui est nécessaire. Vous avez appris la mécanique (private fields, getters, setters), 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 la dissimulation d'informations en action. Vous allez 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.

Vous organiserez votre code en deux fichiers :

wallet.dart : Créez une classe Wallet qui gère l'argent de manière sécurisée. Le portefeuille doit stocker le nom du propriétaire publiquement, mais tout le reste doit être caché derrière une interface publique propre :
- Le solde interne et le journal des transactions doivent être privés - le code externe ne doit jamais voir comment vous stockez ou suivez l'argent
- Une méthode privée doit gérer l'enregistrement des transactions en interne (en stockant des entrées comme "Deposit: $50.0" ou "Withdrawal: $30.0")
- Fournissez une méthode publique deposit(double amount) qui ajoute de l'argent (uniquement si le montant est positif) et enregistre la transaction en interne
- Fournissez une méthode publique withdraw(double amount) qui retire de l'argent uniquement s'il y a des fonds suffisants et que le montant est positif, en enregistrant la transaction en interne. Retournez true en cas de succès, false sinon
- Fournissez un getter public balance qui retourne le solde actuel (accès en lecture seule)
- Fournissez une méthode publique getTransactionCount() qui retourne le nombre de transactions enregistrées (sans exposer la liste réelle des transactions)
- Fournissez une méthode publique getLastTransaction() qui retourne la chaîne de la transaction la plus récente, ou "No transactions" si aucune n'existe
- Incluez une méthode printSummary() qui affiche l'état du portefeuille
main.dart : Importez votre portefeuille et démontrez comment la dissimulation d'informations crée une interface propre et sûre :
- Créez un portefeuille pour le propriétaire "Sarah"
- Déposez 100.0
- Déposez 50.0
- Tentez de retirer 200.0 et affichez "Withdrawal of 200.0: [success/failed]" selon le résultat
- Retirez 30.0 et affichez "Withdrawal of 30.0: [success/failed]"
- Appelez printSummary()
- Affichez "Transaction count: [count]"
- Affichez "Last transaction: [transaction]"

La méthode printSummary() doit afficher :

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

Remarquez comment le code externe peut interagir avec le portefeuille via des méthodes claires et ciblées sans jamais savoir comment le solde est stocké ou comment les transactions sont suivies en interne. Les détails d'implémentation sont complètement cachés - vous pourriez changer la façon 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]"
}