Une discussion approfondie des similitudes et des différences entre les interfaces fonctionnelles Golang et les classes abstraites

Les interfaces fonctionnelles et les classes abstraites sont toutes deux utilisées pour la réutilisabilité du code, mais elles sont implémentées de différentes manières : des interfaces fonctionnelles via des fonctions de référence et des classes abstraites via l'héritage. Les interfaces fonctionnelles ne peuvent pas être instanciées, mais les classes abstraites le peuvent. Les interfaces fonctionnelles doivent implémenter toutes les méthodes déclarées, tandis que les classes abstraites ne peuvent implémenter que certaines méthodes.

Similitudes et différences entre les interfaces fonctionnelles Go et les classes abstraites

Dans le langage Go, les interfaces fonctionnelles et les classes abstraites sont deux concepts importants, tous deux utilisés pour représenter le comportement et permettre la réutilisabilité du code. Cependant, les deux diffèrent dans les scénarios de mise en œuvre et d’utilisation.

Interface fonctionnelle

Une interface fonctionnelle est un type qui fait référence à une fonction avec une signature spécifique. Il définit les paramètres d'entrée et de sortie de la fonction, mais n'a pas besoin d'implémenter le corps de la fonction.

Syntaxe :

type fnType func(parameters) (returnType)

Exemple :

type Handler func(w http.ResponseWriter, r *http.Request)

Classe abstraite

Une classe abstraite est une classe qui ne contient que des déclarations sans implémentation. Il définit une interface qui nécessite des sous-classes pour implémenter ces déclarations.

Syntaxe :

type Interface interface {
    Method1()
    Method2()
}

Similarités et différences

Uniformité :

• Les deux offrent la réutilisabilité du code, permettant la création de composants remplaçables.
• peut être mis en œuvre par différents types.

Différences :

• Méthode d'implémentation : Les interfaces fonctionnelles sont implémentées par référencement de fonctions, tandis que les classes abstraites sont implémentées par héritage.
• Instantiabilité : Les interfaces fonctionnelles ne peuvent pas être instanciées, mais les classes abstraites le peuvent.
• Choix d'implémentation : L'interface fonctionnelle doit implémenter toutes les méthodes déclarées, tandis que la classe abstraite ne peut implémenter que certaines méthodes.
• Syntaxe :  L'interface de fonction utilise le mot-clé func 关键字，而抽象类使用 interface.

Cas pratique

Interface fonctionnelle :

Vous pouvez utiliser des interfaces fonctionnelles pour créer du code faiblement couplé, permettant à différents composants d'utiliser différentes implémentations.

type Shape interface {
    Area() float64
}

type Square struct {
    Side float64
}

func (s *Square) Area() float64 {
    return s.Side * s.Side
}

type Circle struct {
    Radius float64
}

func (c *Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func CalculateArea(shapes []Shape) float64 {
    totalArea := 0.0
    for _, shape := range shapes {
        totalArea += shape.Area()
    }
    return totalArea
}

Classes abstraites :

Vous pouvez utiliser des classes abstraites pour définir des comportements publics et permettre aux sous-classes d'implémenter ou de remplacer ces comportements si nécessaire.

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "Meow!"
}

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!