Bagaimana untuk menentukan kaedah struktur dalam bahasa go

Cara mentakrifkan kaedah struktur dalam bahasa go: 1. Tentukan struktur dengan sintaks "type point struct {....}"; 2. Gunakan struktur sebagai penerima untuk mentakrifkan kaedah struktur, Sintaks "nama kaedah func (jenis penerima pembolehubah penerima) (senarai parameter) (senarai nilai pulangan) {//badan kaedah}". Dalam bahasa Go, jenis penerima boleh menjadi apa-apa jenis, bukan sahaja struktur, tetapi juga apa-apa jenis selain daripada jenis struct.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Kaedah struktur

Bahasa Go mempunyai kedua-dua fungsi dan kaedah Intipati kaedah ialah fungsi, tetapi kaedah dan fungsi mempunyai perbezaan.

Fungsi ialah sekeping kod dengan fungsi bebas yang boleh dipanggil beberapa kali untuk mencapai penggunaan semula kod.

Kaedah ialah fungsi tingkah laku kelas, yang hanya boleh dipanggil oleh objek kelas ini.

Kaedah bahasa Go ialah fungsi yang bertindak pada jenis pembolehubah tertentu. Jenis fungsi khusus ini dipanggil Receiver Konsep penerima adalah serupa dengan kata kunci ini atau diri dalam bahasa berorientasikan objek.

Penerima bahasa Go menekankan bahawa kaedah mempunyai objek tindakan, manakala fungsi tidak mempunyai objek tindakan.

Dalam bahasa Go, jenis penerima boleh menjadi apa-apa jenis, bukan sahaja struktur, tetapi juga apa-apa jenis selain daripada jenis struct. (Seperti integer, rentetan, kepingan, peta dan juga fungsi, dsb.)

Selagi penerima berbeza, nama kaedah boleh sama.

Terdapat kaedah overridden tetapi tiada kaedah terlebih beban(kaedah terlebih beban tidak disokong, iaitu kaedah dengan nama yang sama tetapi parameter berbeza tidak boleh ditakrifkan)

Tentukan kaedah struktur

Penerima boleh menjadi jenis struct atau jenis bukan struct, dan boleh menjadi jenis penunjuk dan jenis bukan penunjuk.

Apabila menamakan pembolehubah dalam penerima, secara rasmi disyorkan untuk menggunakan huruf kecil pertama jenis penerima.

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

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

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

Penerima penunjuk

Fungsi go akan menyalin setiap pembolehubah argumen Jika argumen terlalu besar dan kami ingin mengelak daripada menyalin keseluruhan hujah, kami boleh menggunakan penunjuk untuk menghantar alamat pembolehubah.

Apabila penerima penunjuk memanggil kaedah, pengkompil akan secara tersirat menukar pembolehubah.

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 ialah penerima yang sah: sama seperti sesetengah fungsi membenarkan penunjuk nil sebagai parameter sebenar, penerima kaedah membenarkan penunjuk nil

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

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

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

Pewarisan dan mengatasi kaedah

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

Berorientasikan proses dan berorientasikan objek

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

[Cadangan berkaitan: Pergi tutorial video, Pengajaran pengaturcaraan]

Atas ialah kandungan terperinci Bagaimana untuk menentukan kaedah struktur dalam bahasa go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!