GO語言結構體物件導向操作範例

2022-04-14 19:01:22

匿名欄位初始化

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別
	age  int    //年齡
}
type Student struct {
	Person //只有型別，沒有名字，匿名欄位，繼承了Person的成員
	id     int
	addr   string
}   
func main() {
	//順序初始化
	var s1 Student = Student{Person{"mike", 'm', 18}, 1, "bj"}
	fmt.Println("s1 = ", s1)
	//自動推導型別
	s2 := Student{Person{"mike", 'm', 18}, 1, "bj"}
	//fmt.Println("s2 = ", s2)
	//%+v, 顯示更詳細
	fmt.Printf("s2 = %+vn", s2)
	//指定成員初始化，沒有初始化的常用自動賦值為0
	s3 := Student{id: 1}
	fmt.Printf("s3 = %+vn", s3)
	s4 := Student{Person: Person{name: "mike"}, id: 1}
	fmt.Printf("s4 = %+vn", s4)
	//s5 := Student{"mike", 'm', 18, 1, "bj"} //err
}

成員的操作

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
type Student struct {
	Person //只有型別，沒有名字，匿名欄位，繼承了Person的成員
	id     int
	addr   string
}
func main() {
	s1 := Student{Person{"mike", 'm', 18}, 1, "bj"}
	s1.name = "yoyo"
	s1.sex = 'f'
	s1.age = 22
	s1.id = 666
	s1.addr = "sz"
	s1.Person = Person{"go", 'm', 18}
	fmt.Println(s1.name, s1.sex, s1.age, s1.id, s1.addr)
}

同名欄位

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
type Student struct {
	Person //只有型別，沒有名字，匿名欄位，繼承了Person的成員
	id     int
	addr   string
	name   string //和Person同名了
}
func main() {
	//宣告（定義一個變數）
	var s Student
	//預設規則（糾結原則），如果能在本作用域找到此成員，就操作此成員
	//					如果沒有找到，找到繼承的欄位
	s.name = "mike" //操作的是Student的name，還是Person的name?, 結論為Student的
	s.sex = 'm'
	s.age = 18
	s.addr = "bj"
	//顯式呼叫
	s.Person.name = "yoyo" //Person的name
	fmt.Printf("s = %+vn", s)
}

非結構體匿名欄位

package main
import "fmt"
type mystr string //自定義型別，給一個型別改名
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
type Student struct {
	Person //結構體匿名欄位
	int    //基礎型別的匿名欄位
	mystr
}
func main() {
	s := Student{Person{"mike", 'm', 18}, 666, "hehehe"}
	fmt.Printf("s = %+vn", s) //s = {Person:{name:mike sex:109 age:18} int:666 mystr:hehehe}
	s.Person = Person{"go", 'm', 22}
	fmt.Println(s.name, s.age, s.sex, s.int, s.mystr)  // go 22 109 666 hehehe
	fmt.Println(s.Person, s.int, s.mystr)  // {go 109 22} 666 hehehe
}

結構體指標型別匿名欄位

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
type Student struct {
	*Person //指標型別
	id      int
	addr    string
}
func main() {
	s1 := Student{&Person{"mike", 'm', 18}, 666, "bj"}
	fmt.Println(s1.name, s1.sex, s1.age, s1.id, s1.addr)
	//先定義變數
	var s2 Student
	s2.Person = new(Person) //分配空間
	s2.name = "yoyo"
	s2.sex = 'm'
	s2.age = 18
	s2.id = 222
	s2.addr = "sz"
	fmt.Println(s2.name, s2.sex, s2.age, s2.id, s2.addr)
}

程式導向和物件函數的區別

package main
import "fmt"
//實現2數相加
//程式導向
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, 1) //普通函數呼叫方式
	//fmt.Println("result = ", result)
	//定義一個變數
	var a long = 2
	//呼叫方法格式： 變數名.函數(所需引數)
	r := a.Add02(3)
	fmt.Println("r = ", r)
	//物件導向只是換了一種表現形式
}

為結構體型別新增方法

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
//帶有接收者的函數叫方法
func (tmp Person) PrintInfo() {
	fmt.Println("tmp = ", tmp)
}
//通過一個函數，給成員賦值
func (p *Person) SetInfo(n string, s byte, a int) {
	p.name = n
	p.sex = s
	p.age = a
}
func main() {
	//定義同時初始化
	p := Person{"mike", 'm', 18}
	p.PrintInfo()  //tmp =  {mike 109 18}
	//定義一個結構體變數
	var p2 Person
	(&p2).SetInfo("yoyo", 'f', 22)
	p2.PrintInfo() //tmp =  {yoyo 102 22}
}

指標變數方法集

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
func (p Person) SetInfoValue() {
	fmt.Println("SetInfoValue")
}
func (p *Person) SetInfoPointer() {
	fmt.Println("SetInfoPointer")
}
func main() {
	//結構體變數是一個指標變數，它能夠呼叫哪些方法，這些方法就是一個集合，簡稱方法集
	p := &Person{"mike", 'm', 18}
	p.SetInfoPointer() //func (p *Person) SetInfoPointer()
	(*p).SetInfoPointer() //把(*p)轉換層p後再呼叫，等價於上面
	//內部做的轉換， 先把指標p， 轉成*p後再呼叫
	//(*p).SetInfoValue()  //SetInfoValue
	//p.SetInfoValue()  // SetInfoValue
}

普通變數方法集

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
func (p Person) SetInfoValue() {
	fmt.Println("SetInfoValue")
}
func (p *Person) SetInfoPointer() {
	fmt.Println("SetInfoPointer")
}
func main() {
	p := Person{"mike", 'm', 18}
	p.SetInfoPointer() //func (p *Person) SetInfoPointer()
	//內部，先把p, 轉為為&p再呼叫， (&p).SetInfoPointer()
	p.SetInfoValue()  //直接呼叫，內部不需要轉
}

方法的繼承

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
//Person型別，實現了一個方法
func (tmp *Person) PrintInfo() {
	fmt.Printf("name=%s, sex=%c, age=%dn", tmp.name, tmp.sex, tmp.age)
}
//有個學生，繼承Person欄位，成員和方法都繼承了
type Student struct {
	Person //匿名欄位
	id     int
	addr   string
}
func main() {
	s := Student{Person{"mike", 'm', 18}, 666, "bj"}
	s.PrintInfo()
}

方法的重寫

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
//Person型別，實現了一個方法
func (tmp *Person) PrintInfo() {
	fmt.Printf("name=%s, sex=%c, age=%dn", tmp.name, tmp.sex, tmp.age)
}
//有個學生，繼承Person欄位，成員和方法都繼承了
type Student struct {
	Person //匿名欄位
	id     int
	addr   string
}
//Student也實現了一個方法，這個方法和Person方法同名，這種方法叫重寫
func (tmp *Student) PrintInfo() {
	fmt.Println("Student: tmp = ", tmp)
}
func main() {
	s := Student{Person{"mike", 'm', 18}, 666, "bj"}
	//就近原則：先找本作用域的方法，找不到再用繼承的方法
	s.PrintInfo() //到底呼叫的是Person， 還是Student， 結論是Student
	//顯式呼叫繼承的方法
	s.Person.PrintInfo()
}

方法值

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
func (p Person) SetInfoValue() {
	fmt.Printf("SetInfoValue: %p, %vn", &p, p)
}
func (p *Person) SetInfoPointer() {
	fmt.Printf("SetInfoPointer: %p, %vn", p, p)
}
func main() {
	p := Person{"mike", 'm', 18}
	fmt.Printf("main: %p, %vn", &p, p)
	//p.SetInfoPointer() //傳統呼叫方式
	//儲存方式入口地址
	pFunc := p.SetInfoPointer //這個就是方法值，呼叫函數時，無需再傳遞接收者，隱藏了接收者
	pFunc()                   //等價於 p.SetInfoPointer()
	vFunc := p.SetInfoValue
	vFunc() //等價於 p.SetInfoValue()
}

方法表示式

package main
import "fmt"
type Person struct {
	name string //名字
	sex  byte   //性別, 字元型別
	age  int    //年齡
}
func (p Person) SetInfoValue() {
	fmt.Printf("SetInfoValue: %p, %vn", &p, p)
}
func (p *Person) SetInfoPointer() {
	fmt.Printf("SetInfoPointer: %p, %vn", p, p)
}
func main() {
	p := Person{"mike", 'm', 18}
	fmt.Printf("main: %p, %vn", &p, p)
	//方法值   f := p.SetInfoPointer //隱藏了接收者
	//方法表示式
	f := (*Person).SetInfoPointer
	f(&p) //顯式把接收者傳遞過去 ====》 p.SetInfoPointer()
	f2 := (Person).SetInfoValue
	f2(p) //顯式把接收者傳遞過去 ====》 p.SetInfoValue()
}

以上就是GO語言結構體物件導向操作範例的詳細內容，更多關於GO語言結構體物件導向的資料請關注it145.com其它相關文章！