Les interfaces (partie I)

C'est quoi une interface?

Une interface dans le monde de l'objet orienté est" Une interface définie le comportement d'un objet. Une interface indique ce qu'un objet doit faire. La manière d'aboutir à ce comportement dépend de l'objet.

En Go, une interface est un ensemble de signature de méthodes. Quand un type fournit une définition de toutes les méthodes dans une interface, il est demandé d'implémenter l'interface. Cela est similaire à ce qui se passe dans le monde de programmation orientée objet. Une interface indique quelles sont les méthodes qu'un type doit avoir et le type décide comment implémenter ces méthodes.

Par exemple LaveLinge peut être une interface avec des signatures de méthodes Nettoyage() et Sechage(). Tout type fournissant une définition pour Nettoyage() et Sechage() est supposé implémenter l'interface LaveLinge.

Déclaration et implémentation d'une interface

Voici un exemple pour créer une interface et l'implémenter.

package main

import (  
    "fmt"
)

//definition de l'interface 
type DecouvreVoyelles interface {  
    TrouveVoyelles() []rune
}

type MyString string

//MyString implemente DecouvreVoyelle
func (ms MyString)  TrouveVoyelles() []rune {  
    var voyelles []rune
    for _, rune := range ms {
        if rune == 'a' || rune == 'e' || rune == 'i' || rune == 'o' || rune == 'u' {
            voyelles = append(voyelles, rune)
        }
    }
    return voyelles
}

func main() {  
    nom:= MyString("Maria Rodriguez")
    var v DecouvreVoyelles
    v = nom // possible puisque MyString implemente DecouvreVoyelles
    fmt.Printf("Les voyelles sont %c", v.TrouveVoyelles())

}

Dans le programme ci-dessus, on a crée un type interface appelé DecouvreVoyelles qui a une méthode TrouveVoyelles() []rune.

On a ajouté une méthode TrouveVoyelles() []rune pour recevoir le type Mystring. Maintenant Mystring est supposé implémenter l'interface DecouvreVoyelles. Les interfaces en Go sont implémentées implicitement si un type contient toutes les méthodes déclarées dans une interface contrairement à d'autres langages comme Java.

On affecte à nom qui est de type Mystring v qui est de type DecouvreVoyelles. Cela est possible car Mystring implémente DecouvreVoyelles. v.TrouveVoyelles fait appel à la méthode TrouveVoyelles pour un type Mystring et affiche toutes les voyelles dans la chaîne de caractères Maria Rodriguez. La sortie du programme seraitLes voyelles sont [a i o u ].

Utilisation pratique d'une interface

Le programme ci-dessus nous a appris à implémenter une interface, mais il nous a pas montré comment utiliser une interface d'une manière pratique. Si on utilise à la place de v.TrouveVoyelles nom.Trouvevoyelles, cela allait marcher et on allait pas avoir besoin de l'interface créée.

On va écrire un programme qui calcule les charges d'une société en se basant sur les salaires individuels de chaque employé, par souci de brièveté, on a supposé que tous les frais son en USD(Dollar).

package main

import (  
    "fmt"
)

type CalculSalaire interface {  
    SalaireCalcul() int
}

type Permanent struct {  
    empId    int
    basicpay int
    pf       int
}

type Contrat struct {  
    empId  int
    basicpay int
}

//salaire d'un employé permanent est la somme de basic pay et pf 
func (p Permanent) SalaireCalcul() int {  
    return p.basicpay + p.pf
}

//salaire d'un employé avec contrat est basic pay 
func (c Contrat) SalaireCalcul() int {  
    return c.basicpay
}

/*
Charge totale est calculée en itérant sur les tranches de CalculSalaire et la  somme des salaires des employés 
*/
func chargeTotal(s CalculSalaire[]) {  
    charge := 0
    for _, v := range s {
        charge = charge + v.SalaireCalcul()
    }
    fmt.Printf("Charge totale par mois  $%d", charge)
}

func main() {  
    pemp1 := Permanent{1, 5000, 20}
    pemp2 := Permanent{2, 6000, 30}
    cemp1 := Contract{3, 3000}
    employees := []CalculSalaire{pemp1, pemp2, cemp1}
   chargeTotale(employees)

}

On a déclaré dans l'interface ci-dessus l'interface CalculSalaire avec une seule méthode SalaireCalcul() int.

On a deux types d'employés dans la société, les employés permanents et ceux qui travaillent avec un contrat, les deux types d'employés sont définis par des structures. Le salaire des employés permanents est la somme de basicpay et pf alors que le salaire des employés qui travaillent avec un contrat est uniquement basicpay. Permanent et Contrat implémentent tous les deux l'interface CalculSalaire.

La méthode déclarée chargeTotale prend comme paramètre une tranche de l'interface CalculSalaire. On passe une tranche qui contient les deux types Permanent et Contrat à la méthode chargeTotale.

Le plus grand avantage est que chargeTotale peut s'étendre sur tout nouveau type d'employé sans avoir besoin de changer le code. Supposons que la compagnie a besoin d'ajouter un nouveau type d'employés Freelancer avec une structure de salaire différente. Freelancer peut être passé comme un argument de tranche à chargeTotale sans changer le code de la méthode chargetotale. Freelancer va aussi implémenter l'interface CalculSalaire.

La sortie du programme est Charge totale par mois $14050.

---

Posted on Utopian.io - Rewarding Open Source Contributors

---