Masquage d'information

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 41 sur 91.

Le masquage d'informations est le principe qui sous-tend l'encapsulation - l'idée qu'une classe ne doit exposer que ce qui est nécessaire et masquer ses détails d'implémentation internes. Alors que les modificateurs d'accès et les getters/setters sont les outils, le masquage d'informations est la philosophie de conception qui guide la manière dont vous les utilisez.

L'objectif est de créer une frontière claire entre ce qu'une classe fait (son interface publique) et comment elle le fait (son implémentation interne). Cette séparation signifie que vous pouvez modifier le fonctionnement interne sans affecter le code qui utilise la classe :

<?php
class Temperature {
    private float $celsius;
    
    public function setCelsius(float $value): void {
        $this->celsius = $value;
    }
    
    public function getCelsius(): float {
        return $this->celsius;
    }
    
    public function getFahrenheit(): float {
        return ($this->celsius * 9/5) + 32;
    }
}

$temp = new Temperature();
$temp->setCelsius(25);
echo $temp->getCelsius() . "C = " . $temp->getFahrenheit() . "F";

Sortie :

25C = 77F

La class stocke la température en interne en Celsius, mais les utilisateurs n'ont pas besoin de le savoir. Vous pourriez plus tard modifier le stockage interne en Fahrenheit ou Kelvin, et tant que les méthodes public fonctionnent toujours de la même manière, aucun code externe ne sera interrompu.

Point clé : Le masquage d'informations protège votre code des modifications. Masquez les détails d'implémentation, n'exposez que des interfaces stables, et vos classes deviendront plus faciles à maintenir et à modifier au fil du temps.

Défi

Facile

Construisons un convertisseur de devises qui démontre le masquage d'informations en action. Vous allez créer une classe qui stocke l'argent en interne dans une seule devise mais qui peut se convertir de manière transparente vers et depuis plusieurs devises — sans que le code externe ne sache jamais comment les données sont réellement stockées.

Vous organiserez votre code sur deux fichiers :

Money.php — Créez une classe Money qui stocke en interne tous les montants en cents (sous forme d'entier) pour éviter les problèmes de précision des nombres à virgule flottante. Ce détail d'implémentation doit être complètement caché aux utilisateurs de la classe. La classe doit fournir :
- Une propriété privée pour stocker le montant en cents
- setDollars(float $amount) — accepte un montant en dollars et le stocke en interne sous forme de cents
- getDollars() — renvoie le montant en dollars (float, 2 décimales)
- setEuros(float $amount) — accepte des euros et les convertit en cents en utilisant le taux : 1 EUR = 1.10 USD
- getEuros() — renvoie le montant converti en euros (float, 2 décimales)
- getInternalValue() — renvoie la valeur brute en cents (integer) à des fins de débogage
main.php — Incluez le fichier Money. Vous recevrez deux entrées : un montant en dollars et un montant en euros. Créez une instance de Money. Tout d'abord, définissez le montant en dollars (converti en float) et affichez trois lignes : la valeur en dollars, l'équivalent en euros et la valeur interne en cents. Ensuite, définissez le montant en euros (converti en float) et affichez à nouveau les trois mêmes valeurs.

La beauté de cette conception est que le code externe travaille avec des valeurs familières en dollars et en euros, ignorant complètement que tout est stocké sous forme de cents en interne. Vous pourriez plus tard modifier le stockage interne pour utiliser une devise de base différente ou une stratégie de précision différente, et tant que les méthodes publiques continuent de fonctionner correctement, aucun code externe n'aurait besoin d'être modifié.

Formatez toutes les sorties en dollars et en euros avec exactement 2 décimales. Chaque valeur doit être affichée sur sa propre ligne, ce qui donne un total de six lignes de sortie.

Aide-mémoire

Le masquage d'informations est le principe derrière l'encapsulation - exposer uniquement ce qui est nécessaire tout en cachant les détails d'implémentation interne. Cela crée une frontière claire entre ce qu'une classe fait (interface publique) et comment elle le fait (implémentation interne).

Exemple de masquage d'informations avec une classe Temperature :

<?php
class Temperature {
    private float $celsius;
    
    public function setCelsius(float $value): void {
        $this->celsius = $value;
    }
    
    public function getCelsius(): float {
        return $this->celsius;
    }
    
    public function getFahrenheit(): float {
        return ($this->celsius * 9/5) + 32;
    }
}

$temp = new Temperature();
$temp->setCelsius(25);
echo $temp->getCelsius() . "C = " . $temp->getFahrenheit() . "F";
// Sortie : 25C = 77F

La classe stocke la température en interne en Celsius, mais les utilisateurs n'ont pas besoin de le savoir. Le stockage interne pourrait être modifié en Fahrenheit ou en Kelvin sans casser le code externe, tant que les méthodes publiques continuent de fonctionner de la même manière.

Avantages clés : Le masquage d'informations protège le code des changements. En cachant les détails d'implémentation et en n'exposant que des interfaces stables, les classes deviennent plus faciles à maintenir et à modifier au fil du temps.

Essayez vous-même

<?php

require_once 'Money.php';

// Lire les entrées
$dollarAmount = floatval(trim(fgets(STDIN)));
$euroAmount = floatval(trim(fgets(STDIN)));

// TODO: Créer une instance de Money

// TODO: Définir le montant en dollars et afficher :
// - La valeur en dollars (2 décimales)
// - L'équivalent en euros (2 décimales)
// - La valeur interne en cents (entier)

// TODO: Définir le montant en euros et afficher :
// - La valeur en dollars (2 décimales)
// - L'équivalent en euros (2 décimales)
// - La valeur interne en cents (entier)

?>