Le langage Go fournit un mécanisme d'interface, qui est un moyen important de réutilisation du code et de programmation orientée objet. Dans Go, un type d'interface est une collection de signatures pour un ensemble de méthodes. Les valeurs des types d'interface peuvent stocker n'importe quelle valeur qui implémente ces méthodes.
En langage Go, une interface est un conteneur utilisé pour stocker et transférer un ensemble de méthodes. Les interfaces peuvent découpler le code dans une large mesure, améliorant ainsi la flexibilité et l’évolutivité du code. La conception des interfaces est une partie très importante du langage Go. Une compréhension approfondie des méthodes d’implémentation des interfaces est cruciale pour écrire du code Go de haute qualité.
Ensuite, nous présenterons l'implémentation de la méthode d'interface dans Golang.
1. La définition de l'interface en langage Golang
Go stipule dans la définition de l'interface que l'interface est composée d'un ensemble de méthodes. Nous pouvons définir une interface en définissant un ensemble de méthodes sur le type d'interface :
type interfaceName interface {
method_1 (param1 type1, param2 type2) return_type
method_2 (param1 type1, param2 type2) return_type
…
method_n (param1 type1, param2 type2) return_type
}
La méthode définie dans la définition de l'interface peut être constituée d'une ou plusieurs méthodes. Chaque méthode définit une opération et spécifie les paramètres et le type de retour de l'opération. L’ensemble des méthodes d’une interface est généralement décrit avec de simples commentaires. Si une interface ne contient qu’une seule méthode, alors l’interface est appelée un type de fonction.
2. Implémentation de l'interface en Golang
En langage Go, pour implémenter une interface, il vous suffit d'implémenter toutes les méthodes de l'interface. C'est-à-dire que lorsqu'un type définit toutes les méthodes contenues dans l'interface, le type implémente automatiquement l'interface. Puisqu'il n'y a pas de syntaxe d'implémentation explicite dans Go, l'ensemble des interfaces implémentées par un type est automatiquement déterminé par le type.
type InterfaceObject interface {
Func1() int
Func2() float64
}
type Impl1 struct {
Property1 int
}
func (impl Impl1) Func1() int {
return impl.Property1
}
func (impl Impl1) Func2() float64{
return float64(impl.Property1) / 0.618
}
func main() {
impl1 := Impl1{Property1:100}
var intf InterfaceObject = impl1
fmt.Printf( "%dn", intf.Func1())
fmt.Printf("%.2fn", intf.Func2())
}
Pour l'implémentation d'interface en langage Go, le type qui implémente une interface spécifique est un type de données qui implémente cette interface et peut attribuer des valeurs d'objet de ce type à cet objet d'interface.
3. Polymorphisme d'interface en Golang
En Golang, chaque variable d'un type qui implémente une interface est appelée un objet d'interface. Le type de variable est le nom de l'interface et la valeur de la variable est une instance de l'interface. Une instance ou un pointeur d'un type peut être affecté à une variable d'interface. Lorsque vous devez accéder à une méthode dans un objet d'interface, le programme utilisera le nom de l'interface comme nom de méthode dans l'interface au lieu d'utiliser le type spécifique.
type InterfaceObject interface {
Func1() int
}
type Impl1 struct {
Property1 int
}
func (impl Impl1) Func1() int {
return impl.Property1
}
func main() {
impl1 := Impl1{Property1:100}
var intf InterfaceObject = impl1
fmt.Printf("%d\n", intf.Func1())}
Pour Polymorphisme d'interface de Golang, nous pouvons voir que lors de la création d'un objet d'interface, le type impl1 est automatiquement converti en une valeur de type InterfaceObject, et la méthode Func1() d'InterfaceObject peut être appelée.
4. Imbrication d'interfaces en Golang
En langage Go, l'imbrication d'interfaces est un mécanisme permettant de combiner des types d'interfaces. Les interfaces imbriquées combinent les méthodes de plusieurs interfaces afin qu'un certain type puisse satisfaire simultanément aux exigences de méthode de ces interfaces.
type Drawer interface {
Draw() string
}
type Closer interface {
Close() bool
}
type FileHandler interface {
Drawer Closer
}
func main() {
fh := FileHandler{}
fmt.Print(fh.Draw()) //输出为空字符串
fmt.Print(fh.Close()) //输出false}
Dans le code ci-dessus, définissez Là Il existe trois interfaces Drawer, Closer et Filehandler. Drawer et Closer sont deux interfaces simples, et FileHandler contient deux interfaces, Drawer et Closer. En combinant des interfaces, nous pouvons définir des types d'interfaces plus complexes et rendre l'implémentation plus flexible et extensible.
Résumé
En langage Go, l'interface est un outil de programmation très puissant et important. Grâce à la mise en œuvre de l'interface, la réutilisation du code, la flexibilité et l'évolutivité peuvent être mieux obtenues, ce qui est très courant dans le développement réel. Techniquement parlant, le polymorphisme, la composition, les modèles de conception, etc. peuvent être obtenus grâce à l'utilisation d'interfaces. Par conséquent, une étude approfondie de l'utilisation des interfaces du langage Go et de la mise en œuvre des méthodes est cruciale pour écrire du code Go de haute qualité
.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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
