GO語言結構體面向對象操作示例
更新時間：2022年04月14日 16:43:32 作者：Jeff的技術棧
這篇文章主要介紹了GO語言編程中結構體面向對象的操作示例，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步早日升職加薪
匿名字段初始化
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 = %+v\n", s2)
//指定成員初始化，沒有初始化的常用自動賦值為0
s3 := Student{id: 1}
fmt.Printf("s3 = %+v\n", s3)
s4 := Student{Person: Person{name: "mike"}, id: 1}
fmt.Printf("s4 = %+v\n", 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
//默認規(guī)則（糾結原則），如果能在本作用域找到此成員，就操作此成員
// 如果沒有找到，找到繼承的字段
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 = %+v\n", 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 = %+v\n", 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)
}
面向過程和對象函數的區(qū)別
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=%d\n", 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=%d\n", 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, %v\n", &p, p)
}
func (p *Person) SetInfoPointer() {
fmt.Printf("SetInfoPointer: %p, %v\n", p, p)
}
func main() {
p := Person{"mike", 'm', 18}
fmt.Printf("main: %p, %v\n", &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, %v\n", &p, p)
}
func (p *Person) SetInfoPointer() {
fmt.Printf("SetInfoPointer: %p, %v\n", p, p)
}
func main() {
p := Person{"mike", 'm', 18}
fmt.Printf("main: %p, %v\n", &p, p)
//方法值 f := p.SetInfoPointer //隱藏了接收者
//方法表達式
f := (*Person).SetInfoPointer
f(&p) //顯式把接收者傳遞過去 ====》 p.SetInfoPointer()
f2 := (Person).SetInfoValue
f2(p) //顯式把接收者傳遞過去 ====》 p.SetInfoValue()
}
以上就是GO語言結構體面向對象操作示例的詳細內容，更多關于GO語言結構體面向對象的資料請關注腳本之家其它相關文章！
相關文章
Golang并發(fā)繞不開的重要組件之Channel詳解
Channel是一個提供可接收和發(fā)送特定類型值的用于并發(fā)函數通信的數據類型，也是Golang并發(fā)繞不開的重要組件之一，本文就來和大家深入聊聊Channel的相關知識吧2023-06-06
這篇文章主要介紹了Go+Redis實現延遲隊列實操，延遲隊列是一種非常使用的數據結構，我們經常有需要延遲推送處理消息的場景，比如延遲60秒發(fā)送短信，延遲30分鐘關閉訂單，消息消費失敗延遲重試等2022-09-09
Go?chassis云原生微服務開發(fā)框架應用編程實戰(zhàn)
這篇文章主要為大家介紹了Go?chassis云原生微服務開發(fā)框架應用編程實戰(zhàn)示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-08-08
基于context.Context的Golang?loader緩存請求放大問題解決
這篇文章主要為大家介紹了基于context.Context的Golang?loader緩存請求放大解決方案，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-05-05
為了更深入了解golang連接池的實現，自已又重寫了一遍連接池。文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-08-08
有時python需要引用go的一些開源庫,這時就需要go編譯成python可調用的庫,本文給大家介紹了go編譯so庫讓python引用,編譯后沒有.h文件的問題,需要的朋友可以參考下2024-02-02
這篇文章主要為大家介紹了非常適合PHP同學使用的GoFrame框架設計思想使用體驗及學習建議介紹，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
這篇文章主要為大家介紹了Makefile構建Golang項目的過程示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-07-07
這篇文章來和大家一起探討一下Go?中如何高效使用?timer,特別是與select?一起使用時,如何防止?jié)撛诘膬却嫘孤﹩栴},感興趣的可以了解下2024-01-01
golang如何使用gomobile進行Android開發(fā)
golang可以開發(fā)android,使用golang開發(fā)android需要下載安裝gomobile,下面這篇文章主要給大家介紹了關于golang如何使用gomobile進行Android開發(fā)的相關資料,需要的朋友可以參考下2023-01-01