Interface de programmation orientée objet Golang

introduction de base

Dans le langage Go, l'interface (interface) est un type, un type abstrait.

Interface est une collection d'un ensemble de méthodes, qui est une manifestation de la programmation de type canard. Ce que fait l'interface, c'est comme définir un protocole (règle). Tant qu'une machine a la fonction de laver le linge et de sécher, je l'appelle une machine à laver. Ne vous souciez pas des attributs (données), ne vous souciez que des comportements (méthodes).

À Golang, le polymorphisme se reflète principalement à travers les interfaces.

Interface de démarrage rapide

Utilisez le programme pour simuler le scénario d'application dans l'image ci-dessus.

package main

import(
	"fmt"
)

//定义一个接口
type Usb interface{
    
    
	//声明了两个没有实现的方法
	Start()
	Stop()
}

type Phone struct{
    
    

}

//让Phone实现Usb接口的方法
func (p Phone) Start(){
    
    
	fmt.Println("手机开始工作了.....")
}
func (p Phone) Stop(){
    
    
	fmt.Println("手机停止工作了.....")
}

type Camera struct{
    
    

}
//让Camera实现Usb接口
func (c Camera) Start(){
    
    
	fmt.Println("相机开始工作了.....")
}
func (c Camera) Stop(){
    
    
	fmt.Println("相机停止工作了.....")
}

//计算机
type Computer struct{
    
    

}

//编写一个方法Working,接受一个Usb接口类型的变量

func (c Computer) Working(usb Usb){
    
    
	//通过usb接口变量来调用Start和Stop方法
	usb.Start()
	usb.Stop()
}

func main()  {
    
    
	computer := Computer{
    
    }
	phone := Phone{
    
    }
	camera := Camera{
    
    }

	computer.Working(phone)
	computer.Working(camera)
}

résultat de l'opération:

Grammaire de base

Le type d'interface peut définir un ensemble de méthodes, mais celles-ci n'ont pas besoin d'être implémentées. Et l'interface ne peut contenir aucune variable. Lorsqu'un type personnalisé (tel que la structure Phone) doit être utilisé, écrivez ces méthodes en fonction de la situation spécifique.
Syntaxe de base:

type 接口名 interface{
    
    
    method1(参数列表) 返回值列表
    method2(参数列表) 返回值列表
}

Description:

• Toutes les méthodes de l'interface n'ont pas de corps de méthode, c'est-à-dire que les méthodes de l'interface sont des méthodes qui ne sont pas implémentées. L'interface incarne l'idée de polymorphisme et de cohésion élevée et de faible couplage en programmation.
• L'interface de Golang n'a pas besoin d'être implémentée explicitement. Tant qu'il existe une variable contenant toutes les méthodes du type d'interface, cette variable implémente l'interface. Il n'y a pas de mot-clé comme implémentation dans Golang.

Précautions d'utilisation de l'interface

• L'interface elle-même ne peut pas créer d'instance , mais elle peut pointer vers une variable (instance) d'un type personnalisé qui implémente l'interface

package main

import(
	"fmt"
)

type AInterface interface{
    
    
	Say()
}
type stu struct{
    
    
	name string
}
func (s stu)Say(){
    
    
	fmt.Println("stu Say()...")
}
func main(){
    
    
	var s stu
	var a AInterface = s
	a.Say()
}

• Toutes les méthodes de l'interface n'ont pas de corps de méthode, c'est-à-dire qu'elles sont toutes des méthodes qui ne sont pas implémentées.
• Dans Golang, un type personnalisé doit implémenter toutes les méthodes d'une interface. Nous disons que ce type personnalisé implémente l'interface.
• Ce n'est que lorsqu'un type personnalisé implémente une certaine interface qu'une instance du type personnalisé peut être affectée au type d'interface.
• Tant qu'il s'agit d'un type de données personnalisé, il peut implémenter une interface, pas seulement un type de structure.

package main

import(
	"fmt"
)

type AInterface interface{
    
    
	Say()
}
func (i integer)Say(){
    
    
	fmt.Println("integer Say()...")
}

type integer int
func main(){
    
    
	var i integer
	var a AInterface = i
	a.Say()
}

résultat de l'opération:

• Un type personnalisé peut implémenter plusieurs interfaces.

• Il ne peut pas y avoir de variables secondaires dans l'interface golang.
  

• Le type d'interface est un pointeur (type référence) par défaut. S'il est utilisé sans initialiser l'interface, il affichera nil.

• L'interface vide {} n'a pas de méthode, donc tous les types implémentent l'interface vide. Nous pouvons assigner n'importe quelle variable à l'interface vide.

package main
import(
	"fmt"
)
type T interface{
    
    
	
}
func main(){
    
    
	var i int = 100
	var t T = i
	fmt.Println(t)
}

Lien vers la page d'accueil du blogueur: https://blog.csdn.net/weixin_44736475 L'
originalité n'est pas facile, j'espère que vous pourrez la soutenir.Si
l'article vous est utile, pensez à cliquer sur trois liens! ❤️❤️❤️