Le langage Go peut-il développer des interfaces ?

Le langage Go peut développer des interfaces. L'interface dans le langage Go est la signature d'un ensemble de méthodes. C'est une partie importante du langage Go. Ce que fait l'interface, c'est comme définir une spécification ou un protocole. Chaque partie implémenteuse n'a qu'à l'implémenter selon le protocole. Le mot-clé interface est utilisé dans le langage go pour définir l'interface. La syntaxe est "type interface nom du type interface{nom de la méthode 1 (liste de paramètres 1) liste de valeurs de retour 1 nom de la méthode 2 (liste de paramètres 2) liste de valeurs de retour 2. .}".

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

L'interface devrait être un concept familier pour nous. Elle est largement utilisée dans divers langages de développement. Pour les programmeurs comme nous qui sont plus familiers avec Java, les interfaces sont plus familières. Voyons comment les interfaces sont utilisées dans le langage Go. , et le rôle que jouent les interfaces dans le développement quotidien.

Concept

Dans le langage Go, l'interface est la signature d'un ensemble de méthodes. C'est une partie importante du langage Go. Ce que fait l'interface, c'est comme définir une spécification ou un protocole. pour le mettre en œuvre selon le protocole.

L'interface est un type

Le type d'interface est une abstraction et une généralisation du comportement d'autres types. Il ne se soucie pas des détails d'implémentation spécifiques. Cette méthode abstraite peut rendre nos fonctions plus flexibles.

Définition de l'interface

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

Dans le langage go, nous utilisons le mot-clé interface pour définir l'interface.

Conditions d'implémentation de l'interface

Si l'ensemble de méthodes d'un type T est un sur-ensemble de l'ensemble de méthodes d'un type d'interface, alors nous disons que le type T implémente l'interface.

L'implémentation de l'interface est implicite dans le langage Go, ce qui signifie que la relation d'implémentation entre les deux types n'a pas besoin d'être reflétée dans le code. Il n'y a pas de mot-clé similaire aux implémentations en Java dans le langage Go, et le compilateur Go vérifiera automatiquement la relation d'implémentation entre deux types si nécessaire. Une fois l'interface définie, elle doit être implémentée afin que l'appelant puisse compiler et utiliser correctement l'interface.

L'implémentation d'une interface doit suivre deux règles pour rendre l'interface disponible :

1. La méthode de l'interface est au même format que la méthode de type qui implémente l'interface. La méthode peut être implémentée en ajoutant une méthode. cohérent avec la signature d'interface dans le type. La signature inclut le nom, la liste des paramètres et la liste des paramètres de retour de la méthode. En d'autres termes, tant que le nom, la liste de paramètres et la liste de paramètres de retour de la méthode dans le type d'interface implémenté sont incohérents avec la méthode à implémenter par l'interface, alors cette méthode de l'interface ne sera pas implémentée.

package main

import "fmt"

type Phone interface {
	Call()
	SendMessage()
}

type HuaWei struct {
	Name  string
	Price float64
}

func (h *HuaWei) Call() {
	fmt.Printf("%s:可以打电话",h.Name)
}

func (h *HuaWei) SendMessage() {
	fmt.Printf("%s:可以发送短信",h.Name)
}

func main() {

	h := new(HuaWei)
	h.Name="华为"
	var phone Phone
	phone = h
	phone.SendMessage()
}

Lorsqu'un type ne peut pas implémenter une interface, le compilateur signalera une erreur :

a. Erreurs causées par des noms de fonctions incohérents

b. Erreurs causées par des signatures de méthodes incohérentes pour implémenter des fonctions

2. sont implémentés lorsqu'il y a plusieurs méthodes dans une interface, ce n'est que si ces méthodes sont implémentées que l'interface peut être compilée et utilisée correctement

func (h *Xiaomi) Call() {
	fmt.Printf("%s:可以打电话",h.Name)
}

func main() {
	h := new(Xiaomi)
	h.Name="小米"
	var phone Phone
	phone = h
	phone.SendMessage()
}

Lorsque le type Xiaomi n'implémente qu'une seule méthode dans l'interface, lorsque nous l'utilisons, compilez Signaler une erreur.

La relation entre les types et les interfaces

Un type implémente plusieurs interfaces

Un type peut implémenter plusieurs interfaces, et les interfaces sont indépendantes les unes des autres et ne connaissent pas l'implémentation les unes des autres.

Par exemple, un chien peut bouger et appeler

package main

import "fmt"

type Move interface {
	move()
}
type Say interface {
	say()
}
type Dog struct {
	Name string
}

func (d *Dog) move()  {
	fmt.Printf("%s会动\n", d.Name)
}
func (d *Dog) say()  {
	fmt.Printf("%s会叫汪汪汪\n", d.Name)
}

func main() {
	var m Move
	var s  Say
	d:=&Dog{
		Name: "旺财",
	}
	m = d
	s=d
	m.move()
	s.say()
}

Plusieurs types implémentent la même interface

Différents types dans le langage Go peuvent également implémenter la même interface. Tout d'abord, nous définissons une interface Mover, ce qui nécessite cela. il doit y avoir une méthode de déplacement.

type Mover interface {
    move()
}

Par exemple, les chiens peuvent bouger, et les voitures peuvent également bouger. Vous pouvez utiliser le code suivant pour réaliser cette relation :

type dog struct {
    name string
}

type car struct {
    brand string
}

// dog类型实现Mover接口
func (d dog) move() {
    fmt.Printf("%s会跑\n", d.name)
}

// car类型实现Mover接口
func (c car) move() {
    fmt.Printf("%s速度70迈\n", c.brand)
}

À l'heure actuelle, nous pouvons traiter les chiens et les voitures comme un seul objet en mouvement dans le code, et non. plus besoin d'y prêter attention. Qu'est-ce qu'ils sont spécifiquement, il vous suffit d'appeler leur méthode de déplacement.

func main() {
        var x Mover
        var a = dog{name: "旺财"}
        var b = car{brand: "保时捷"}
        x = a
        x.move()
        x = b
        x.move()
    }

Interface vide

Interface vide : interface{}, ne contient aucune méthode. Pour cette raison, tout type implémente l'interface vide, de sorte que l'interface vide peut stocker n'importe quel type de données.

fmt 包下的 Print Fonctions de série, la plupart de leurs paramètres sont des types d'interface vides, qui peuvent également être considérés comme prenant en charge n'importe quel type

func Print(a ...interface{}) (n int, err error)
func Println(format string, a ...interface{}) (n int, err error)
func Println(a ...interface{}) (n int, err error)

L'interface vide est utilisée comme valeur de la carte

// 空接口作为map值
    var studentInfo = make(map[string]interface{})
    studentInfo["name"] = "李白"
    studentInfo["age"] = 18
    studentInfo["married"] = false
    fmt.Println(studentInfo)

Inférence de type

L'interface vide peut stocker n'importe quel type de valeur, alors que faisons-nous ?

Valeur d'interface

Une valeur d'interface (appelée valeur d'interface) est composée d'un type spécifique et de la valeur du type spécifique.

Ces deux parties sont appelées respectivement type dynamique et valeur dynamique de l'interface.

Si vous souhaitez juger la valeur dans l'interface vide, vous pouvez utiliser l'assertion de type à ce moment-là. Son format de syntaxe est :

x.(T)

où :

• x : représente une variable de type interface{}

• T : représente l'assertion x Probablement le type.

该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。

func main() {
    var x interface{}
    x = "ms的go教程"
    v, ok := x.(string)
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("类型断言失败")
    }
}

 上面的示例中如果要断言多次就需要写多个if判断，这个时候我们可以使用switch语句来实现：

func justifyType(x interface{}) {
    switch v := x.(type) {
    case string:
        fmt.Printf("x is a string，value is %v\n", v)
    case int:
        fmt.Printf("x is a int is %v\n", v)
    case bool:
        fmt.Printf("x is a bool is %v\n", v)
    default:
        fmt.Println("unsupport type！")
    }
}

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。

总结

关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。

【相关推荐：Go视频教程、编程教学】

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!