Analyse du polymorphisme dans Go - aucune interface requise

                                                                                                                                                     

Ce qui suit est une introduction au polymorphisme dans Analyse du polymorphisme dans Go - aucune interface requise from the Colonne tutoriel golang - aucune interface requise, j'espère que cela sera utile aux amis dans le besoin !

Et si vous souhaitez utiliser le polymorphisme dans Analyse du polymorphisme dans Go - aucune interface requise, mais que vous n'aimez pas les interfaces ? Continuez à lire...

Tout d'abord, voyons ce que nous voulons faire :

var dog, duck *Animal

dog = NewDog("fido")
duck = NewDuck("donald")

fmt.Println(dog.makeNoise())
// fido says woof!
fmt.Println(duck.makeNoise())
// donald says quack!

dog et duck ont le même type (*Animal). Chaque variable est instanciée à l'aide d'un constructeur différent, et elles ont un comportement différent lorsque makeNoise la même méthode est appelée.

Habituellement, c'est pour cet exemple que nous utilisons l'interface, mais nous ne voulons pas que l'utilisation réelle soit si simple.

Voyons comment faire fonctionner cela :

Veuillez cliquer ici (https://play.golang.org/p/P5Ovn_K-yyo) pour voir le code complet

type Animal struct {
    makeNoiseFn func(*Animal) string
    name        string
    legs        int
}

La structure Animal contient les attributs name et legs, ainsi qu'un attribut mkeNoiseFn. Cet attribut est en fait une fonction. La fonction accepte un paramètre *Animal et renvoie un. chaîne. La méthode

func (a *Animal) makeNoise() string {
    return a.makeNoiseFn(a)
}

makeNoise n'est en réalité qu'un wrapper qui appelle l'animal correspondant makenoiseFn et prend comme argument un pointeur vers l'animal lui-même.

func NewDog(name string) *Animal {
    return &Animal{
        makeNoiseFn: func(a *Animal) string {
            return a.name + " says woof!"
        },
        legs: 4,
        name: name,
    }
}

func NewDuck(name string) *Animal {
    return &Animal{
        makeNoiseFn: func(a *Animal) string {
            return a.name + " says quack!"
        },
        legs: 4,
        name: name,
    }
}

Maintenant, tout ce que nous avons à faire est de faire en sorte que le même type se comporte différemment et d'attribuer différentes fonctions à ses makeNoiseFn propriétés. Désormais, la méthode makeNoise appelle la fonction correspondante selon que l'animal est un chien ou un canard.

Dois-je faire ça ?

Non !

Cet article est destiné à vous montrer ce que vous pouvez faire, et non ce devriez faire. Si vous devez implémenter le polymorphisme, les interfaces constituent une meilleure approche. Si vous utilisez une interface, ce code ressemblerait à ceci :

type Animal interface {
    makeNoise() string
}

type Dog struct {
    name string
    legs int
}

func (d *Dog) makeNoise() string {
    return d.name + " says woof!"
}

type Duck struct {
    name string
    legs int
}

func (d *Duck) makeNoise() string {
    return d.name + " says quack!"
}

func NewDog(name string) Animal {
    return &Dog{
        legs: 4,
        name: name,
    }
}

func NewDuck(name string) Animal {
    return &Duck{
        legs: 4,
        name: name,
    }
}

func main() {
    var dog, duck Animal

    dog = NewDog("fido")
    duck = NewDuck("donald")

    fmt.Println(dog.makeNoise())
    // fido says woof!
    fmt.Println(duck.makeNoise())
    // donald says quack!
}

Adresse originale : https://www.sohamkamani.com/golang/2019-03-29-polymorphism-without-interfaces/

Adresse de traduction : https://learnku.com/go/t/52404

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!