So definieren Sie eine Strukturmethode in der Go-Sprache

So definieren Sie Strukturmethoden in der Go-Sprache: 1. Definieren Sie eine Struktur mit der Syntax „type point struct {....}“ 2. Definieren Sie die Strukturmethode unter Verwendung der Struktur als Empfänger mit der Syntax „func ( Empfängervariable (Empfängertyp) Methodenname (Parameterliste) (Rückgabewertliste) {//Methodenkörper}". In der Go-Sprache kann der Typ des Empfängers ein beliebiger Typ sein, nicht nur eine Struktur, sondern auch jeder andere Typ als der Strukturtyp.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Strukturmethode

Die Go-Sprache hat sowohl Funktionen als auch Methoden. Die Essenz von Methoden sind Funktionen, aber Methoden und Funktionen haben unterschiedliche Punkte.

Eine Funktion ist ein Codeabschnitt mit unabhängigen Funktionen, der mehrmals aufgerufen werden kann, um eine Wiederverwendung des Codes zu erreichen.

Methode ist eine Verhaltensfunktion einer Klasse, die nur von Objekten dieser Klasse aufgerufen werden kann.

Die Methode der Go-Sprache ist eine Funktion, die auf eine Variable eines bestimmten Typs einwirkt. Diese spezielle Art von Funktion wird als Receiver bezeichnet. Das Konzept eines Empfängers ähnelt den Schlüsselwörtern this oder self in objektorientierten Sprachen.

Der Empfänger der Go-Sprache betont, dass Methoden Aktionsobjekte haben, während Funktionen keine Aktionsobjekte haben.

In der Go-Sprache kann der Empfängertyp ein beliebiger Typ sein, nicht nur eine Struktur, sondern auch jeder andere Typ als der Strukturtyp. (Zum Beispiel Ganzzahlen, Zeichenfolgen, Slices, Karten und sogar Funktionen usw.)

Solange die Empfänger unterschiedlich sind, können die Methodennamen gleich sein.

Es gibt überschriebene Methoden, aber keine überladenen Methoden Ist ein Strukturtyp oder ein Nicht-Strukturtyp, kann ein Zeigertyp und ein Nicht-Zeigertyp sein.

Bei der Benennung von Variablen im Empfänger wird offiziell empfohlen, den ersten Kleinbuchstaben des Empfängertyps zu verwenden.

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

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

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

Zeigerempfänger

Wenn ein Argument zu groß ist und wir vermeiden möchten, das gesamte Argument zu kopieren, können wir einen Zeiger verwenden, um die Adresse der Variablen zu übergeben .

Wenn der Zeigerempfänger eine Methode aufruft, führt der Compiler eine implizite Konvertierung der Variablen durch.

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 ist ein legaler Empfänger: So wie einige Funktionen Nullzeiger als tatsächliche Parameter zulassen, erlaubt der Empfänger einer Methode Nullzeiger

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

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

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

Vererbung und Überschreibung von Methoden

// 声明 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
}

Prozess -orientiert und objektorientiert

//面向过程
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)
 
}

[Verwandte Empfehlungen: Go-Video-Tutorial

,

Programmierunterricht]

Das obige ist der detaillierte Inhalt vonSo definieren Sie eine Strukturmethode in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!