Comment définir la méthode de structure en langage Go

Comment définir des méthodes de structure en langage Go : 1. Définir une structure avec la syntaxe "type point struct {....}" 2. Utiliser la structure comme récepteur pour définir la méthode de structure avec la syntaxe "func ( Variable du récepteur type de récepteur) nom de la méthode (liste de paramètres) (liste des valeurs de retour) {//corps de la méthode}". En langage Go, le type du récepteur peut être n'importe quel type, pas seulement structure, mais aussi n'importe quel type autre que le type struct.

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

Méthode de structure

Le langage Go a à la fois des fonctions et des méthodes. L'essence des méthodes est constituée de fonctions, mais les méthodes et les fonctions ont des points différents.

Une fonction est un morceau de code avec des fonctions indépendantes qui peuvent être appelées plusieurs fois pour réaliser la réutilisation du code.

La méthode est une fonction comportementale d'une classe, qui ne peut être appelée que par les objets de cette classe.

La méthode en langage Go est une fonction qui agit sur une variable d'un type spécifique. Ce type spécifique de fonction est appelé ReceiverLe concept de récepteur est similaire aux mots-clés this ou self dans les langages orientés objet.

Le récepteur du langage Go souligne que les méthodes ont des objets d'action, tandis que les fonctions n'ont pas d'objets d'action.

En langage Go, le type de récepteur peut être n'importe quel type, pas seulement la structure, mais aussi tout type autre que le type struct. (Comme des entiers, des chaînes, des tranches, des cartes et même des fonctions, etc.)

Tant que les récepteurs sont différents, les noms de méthodes peuvent être les mêmes.

Il existe des méthodes surchargées mais pas de méthodes surchargées (les méthodes surchargées ne sont pas prises en charge, c'est-à-dire que les méthodes portant le même nom mais des paramètres différents ne peuvent pas être définis)

définir des méthodes de structure

Le récepteur peut Il s'agit d'un type struct ou d'un type non-struct, et peut être un type pointeur et un type non-pointeur.

Lors de la dénomination des variables dans le récepteur, il est officiellement recommandé d'utiliser la première lettre minuscule du type de récepteur.

// 定义方法的语法格式：
func （接收者变量 接收者类型） 方法名（参数列表） （返回值列表）{
    //方法体
}

// 定义结构体
type point struct {
    X int
    Y int
}

// 定义结构体方法
func (p point) print() {
    fmt.Println(p.X, p.Y)
}

Récepteur de pointeur

La fonction go copiera chaque variable de paramètre réel si un paramètre réel est trop grand et que nous voulons éviter de copier l'intégralité du paramètre réel, nous pouvons utiliser un pointeur pour transmettre l'adresse. de la variable.

Lorsque le récepteur du pointeur appelle une méthode, le compilateur effectuera une conversion implicite de la variable.

type point struct {
    X int
    Y int
}
func (p point) Print() {
    fmt.Println(p.X, p.Y)
}
func (p *point) ScaleBy(factor int) {
    p.X *= factor
    p.Y *= factor
}
func main() {
    p := point{1,1}
    ptr := &p
    p.Print()   //1. 正确
    ptr.Print() //2. 正确
    p.ScaleBy(2)      //3. 正确
    ptr.ScaleBy(2)    //4. 正确
    point{1,1}.Print()    //5. 正确
    (&point{1,1}).Print() //6. 正确
    (&point{1,1}).ScaleBy( 2) //7. 正确
    point{1,1}.ScaleBy( 2)    //8. 错误
}

nil est un récepteur légal : tout comme certaines fonctions autorisent les pointeurs nuls comme paramètres réels, le récepteur d'une méthode autorise les pointeurs nuls

// 定义结构体
type A struct {
    Data int
}

// 定义结构体方法
func (a *A) FunPtrA() {
    fmt.Println("FunPtrA")
}

func main() {
    
    // 声明结构体变量
    var ptrA *A
    
    // 将 nil 赋值给结构体变量
    ptrA = nil
    
    // 调用结构体方法
    ptrA.FunPtrA()  //FunPtrA
}

Héritage et remplacement des méthodes

// 声明 human 结构体
type human struct {
	name, phone string
	age         int8
}
 
// student 继承 human 结构体 所以继承 human 的方法
type student struct {
	human
	school string
}
 
// employee 继承 human 结构体 所以继承 human 的方法
type employee struct {
	human
	company string
}
 
// human 定义 sayHi 方法
func (h human) sayHi() {
	fmt.Printf("我是%s，年龄%d，联系方式%s \n", h.name, h.age, h.phone)
}


// 方法的继承
func testMethod11(){
        // student 继承 human 所以有 sayHi 方法， employee 同理
	s1 := student{human{"s1","138001",13},"第一中学"}
	e1 := employee{human{"e1","138002",30},"第一企业"}
	s1.sayHi()    //我是s1，年龄13，联系方式138001
	e1.sayHi()    //我是e1，年龄30，联系方式138002
}


// 方法的重写 此为重写 非重载
func (s student) sayHi(){
	fmt.Printf("我是%s，年龄%d，我在%s上学，联系方式%s \n", s.name, s.age, s.school,s.phone)
}
 
func testMethod12(){
	s1 := student{human{"s1","138001",13},"第一中学"}
	s1.sayHi()    //我是s1，年龄13，我在第一中学上学，联系方式138001
}

Processus -orienté et orienté objet

//面向过程
func Add01(a, b int) int {
	return a + b
}
 
//面向对象，方法：给某个类型绑定一个函数
type long int
 
//tmp叫接收者，接收者就是传递的一个参数
func (tmp long) Add02(other long) long  {
	return tmp + other
}
 
func main() {
	var result int
	result = Add01(1, 2) //普通函数调用方式
	fmt.Println("result = ", result)
 
	//定义一个变量
	var a long = 2
	//调用方式格式： 变量名，函数(所需参数)
	r := a.Add02(2)
	fmt.Println("r = ", r)
 
}

[Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation]

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!