Champs exportés vs non exportés

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 47 sur 107.

En Go, l'encapsulation au niveau des structures est contrôlée par la casse des noms de champs. Cette règle simple détermine si les champs peuvent être accédés depuis l'extérieur du package où la structure est définie.

Les champs commençant par une lettre majuscule sont exportés—accessibles depuis n'importe quel package. Les champs commençant par une lettre minuscule ne sont pas exportés—uniquement accessibles au sein du même package :

// Dans le package "user"
type User struct {
    Name     string  // Exporté - accessible partout
    Email    string  // Exporté - accessible partout
    password string  // Non exporté - accessible uniquement dans le package "user"
    age      int     // Non exporté - accessible uniquement dans le package "user"
}

Lorsqu'un autre package importe et utilise cette struct, il ne peut interagir qu'avec les champs exportés :

// Dans le package "main"
import "user"

func main() {
    u := user.User{
        Name:  "Alice",      // fonctionne
        Email: "a@mail.com", // fonctionne
        // password: "secret", // erreur de compilation : champ inconnu
    }
    
    fmt.Println(u.Name)     // fonctionne
    // fmt.Println(u.password) // erreur de compilation : impossible de se référer à un champ non exporté
}

Ce mécanisme protège les données sensibles et les détails d'implémentation interne. Le champ password ne peut pas être lu ou modifié directement depuis l'extérieur du paquet, forçant les autres codes à utiliser les méthodes que vous fournissez. C'est l'approche de Go pour réaliser le masquage des données — un principe fondamental de l'encapsulation dans la programmation orientée objet.

Défi

Facile

Construisons un système de compte bancaire qui démontre l'encapsulation à travers des champs exportés et non exportés. Vous allez créer un package qui protège les données financières sensibles tout en exposant des informations publiques sûres.

Vous organiserez votre code sur deux fichiers :

account.go : Créez une structure BankAccount dans le package main qui modélise un compte bancaire réel avec une protection des données appropriée :
- HolderName (exporté) - le nom du titulaire du compte, sûr à afficher publiquement
- AccountType (exporté) - le type de compte (par exemple, "Savings", "Checking")
- balance (non exporté) - le solde réel, qui doit être protégé
- pin (non exporté) - le code PIN du compte, donnée hautement sensible
Ajoutez une fonction constructeur NewBankAccount qui prend le nom du titulaire, le type de compte, le solde initial et le PIN, puis retourne un pointeur vers un nouveau BankAccount. Ajoutez également une méthode GetPublicInfo() string qui retourne le format : Account: [HolderName] ([AccountType])
main.go : Lisez les détails du compte depuis l'entrée, créez un BankAccount en utilisant le constructeur, et démontrez l'encapsulation. Affichez les informations publiques à l'aide de la méthode, puis accédez directement et affichez chaque champ exporté sur des lignes séparées. Les champs non exportés (balance et pin) sont protégés — vous ne pouvez les définir que via le constructeur.

Les entrées suivantes seront fournies :

Ligne 1 : Nom du titulaire du compte
Ligne 2 : Type de compte
Ligne 3 : Solde initial (sous forme de float)
Ligne 4 : Code PIN

Par exemple, avec Alice Johnson, Savings, 5000.50, et 1234, votre sortie devrait être :

Account: Alice Johnson (Savings)
Holder: Alice Johnson
Type: Savings

Remarquez que le solde et le PIN n'apparaissent jamais dans la sortie — ils sont discrètement cachés à l'intérieur de la structure, accessibles uniquement au sein du package. C'est l'encapsulation en action : les données sensibles sont protégées tandis que les informations publiques restent accessibles.

Aide-mémoire

En Go, l'encapsulation est contrôlée par la casse des noms de champs dans les structures :

Les champs en majuscules sont exportés (accessibles depuis n'importe quel package)
Les champs en minuscules sont non exportés (uniquement accessibles au sein du même package)

type User struct {
    Name     string  // Exporté - accessible partout
    Email    string  // Exporté - accessible partout
    password string  // Non exporté - uniquement accessible dans le même package
    age      int     // Non exporté - uniquement accessible dans le même package
}

Lors de l'utilisation d'une structure provenant d'un autre package, seuls les champs exportés sont accessibles :

import "user"

func main() {
    u := user.User{
        Name:  "Alice",      // fonctionne
        Email: "a@mail.com", // fonctionne
        // password: "secret", // erreur de compilation : champ inconnu
    }
    
    fmt.Println(u.Name)     // fonctionne
    // fmt.Println(u.password) // erreur de compilation : impossible de se référer à un champ non exporté
}

Ce mécanisme protège les données sensibles et les détails d'implémentation interne, forçant le code externe à utiliser les méthodes fournies pour l'accès.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire le nom du titulaire du compte
	holderName, _ := reader.ReadString('\n')
	holderName = strings.TrimSpace(holderName)

	// Lire le type de compte
	accountType, _ := reader.ReadString('\n')
	accountType = strings.TrimSpace(accountType)

	// Lire le solde initial
	balanceStr, _ := reader.ReadString('\n')
	balanceStr = strings.TrimSpace(balanceStr)
	balance, _ := strconv.ParseFloat(balanceStr, 64)

	// Lire le PIN
	pinStr, _ := reader.ReadString('\n')
	pin := strings.TrimSpace(pinStr)

	// TODO: Créer un nouveau BankAccount en utilisant le constructeur
	// account := NewBankAccount(...)

	// TODO: Afficher les informations publiques en utilisant la méthode GetPublicInfo()

	// TODO: Afficher le nom du titulaire en accédant directement au champ exporté
	// fmt.Println("Holder:", ...)

	// TODO: Afficher le type de compte en accédant directement au champ exporté
	// fmt.Println("Type:", ...)

	// Note: balance et pin ne sont pas exportés - ils ne peuvent pas être accédés directement ici
	// Ils sont encapsulés en toute sécurité dans la struct

	_ = balance // Supprimez cette ligne lorsque vous utilisez balance
	_ = pin     // Supprimez cette ligne lorsque vous utilisez pin
}