Méthodes et interfaces

Les méthodes : attacher un comportement à un type

Jusqu'ici vos struct ne faisaient que stocker des données. Une méthode leur attache un comportement : c'est une fonction avec un récepteur, déclaré entre func et le nom.

type Compte struct {
    solde float64
}

// Récepteur VALEUR : lecture seule (travaille sur une copie)
func (c Compte) Solde() float64 {
    return c.solde
}

// Récepteur POINTEUR : peut modifier le Compte d'origine
func (c *Compte) Deposer(montant float64) {
    c.solde += montant
}

func main() {
    c := Compte{}
    c.Deposer(50)            // Go prend l'adresse automatiquement
    fmt.Println(c.Solde())   // 50
}

La distinction est cruciale : un récepteur valeur (c Compte) reçoit une copie, donc il ne peut pas modifier l'original. Un récepteur pointeur (c *Compte) reçoit l'adresse, donc il peut muter le type.

Les interfaces : un contrat, pas une hiérarchie

Une interface décrit un comportement attendu : une liste de méthodes. Tout type qui possède ces méthodes satisfait l'interface, automatiquement, sans aucun mot-clé implements. C'est la grande différence avec Java ou PHP.

type Forme interface {
    Aire() float64
}

type Rectangle struct{ L, H float64 }
func (r Rectangle) Aire() float64 { return r.L * r.H }

type Cercle struct{ R float64 }
func (c Cercle) Aire() float64 { return 3.14159 * c.R * c.R }

Rectangle et Cercle n'ont jamais déclaré « je suis une Forme ». Mais comme ils ont tous les deux une méthode Aire() float64, ils satisfont l'interface Forme. Le compilateur le vérifie tout seul.

Le polymorphisme sans héritage

L'intérêt : une fonction qui prend une Forme accepte n'importe quel type qui la satisfait. Pas besoin de classe parente, pas d'arbre d'héritage.

func decrire(f Forme) {
    fmt.Printf("Aire : %.2f\n", f.Aire())
}

func main() {
    decrire(Rectangle{L: 3, H: 4})  // Aire : 12.00
    decrire(Cercle{R: 5})           // Aire : 78.54
}

Ajoutez demain un Triangle avec une méthode Aire() : decrire fonctionnera sans changer une ligne. C'est le polymorphisme à la Go : on programme contre un comportement, pas contre une hiérarchie de types.

Révélation : error est une interface

Souvenez-vous du error de la leçon précédente. Ce n'est pas un type magique : c'est une interface, définie par la bibliothèque standard en trois lignes :

type error interface {
    Error() string
}

N'importe quel type qui possède une méthode Error() string est donc un error valide. C'est ainsi qu'on crée des erreurs riches, qui portent des données :

type ErrSolde struct {
    Manque float64
}

func (e ErrSolde) Error() string {
    return fmt.Sprintf("solde insuffisant : il manque %.2f €", e.Manque)
}

func retirer(solde, montant float64) error {
    if montant > solde {
        return ErrSolde{Manque: montant - solde}  // satisfait error
    }
    return nil
}

Le code appelant peut alors vérifier if err != nil comme d'habitude, mais aussi récupérer la donnée (le montant manquant) avec un type assertion. Les interfaces, c'est exactement ce qui rend le système d'erreurs de Go à la fois simple et extensible.

Le piège de l'interface nil qui n'est pas nil

Une variable d'interface, sous le capot, c'est une boîte à deux cases : le type concret qu'elle contient, et la valeur elle-même. Et la comparaison err == nil regarde les deux cases. C'est là que Go tend son piège le plus célèbre :

Le piège se déclenche presque toujours de la même façon : une fonction qui déclare retourner error mais renvoie un pointeur typé qui vaut nil :

func retirer(solde, montant float64) error {
    var e *ErrSolde               // pointeur nil pour l'instant
    if montant > solde {
        e = &ErrSolde{Manque: montant - solde}
    }
    return e  // ⚠ même si e vaut nil, l'interface ne le sera pas !
}

err := retirer(100, 50)
fmt.Println(err == nil)  // false… alors qu'il n'y a aucune erreur

À toi de jouer

Complète ce programme : ajoute un type Carre avec une méthode Aire() pour qu'il satisfasse l'interface Forme et passe dans decrire. Puis exécute :

package main

import "fmt"

type Forme interface {
    Aire() float64
}

type Rectangle struct{ L, H float64 }

func (r Rectangle) Aire() float64 { return r.L * r.H }

// TODO : ajoute ici un type Carre avec une méthode Aire()

func decrire(f Forme) {
    fmt.Printf("Aire : %.2f\n", f.Aire())
}

func main() {
    decrire(Rectangle{L: 3, H: 4})
    // decrire(Carre{Cote: 5})  // décommente après avoir créé Carre
}