碼上歡樂
相關內容    簡體    繁體

Go語言基礎之構造函數、方法和接收者

本文轉載自   查看原文   2021-10-17 17:55   1210    Go

Go語言基礎之構造函數、方法和接收者

一、構造函數

Go語言的結構體沒有構造函數，我們可以自己實現。 例如，下方的代碼就實現了一個person的構造函數。 因為struct是值類型，如果結構體比較復雜的話，值拷貝性能開銷會比較大，所以該構造函數返回的是結構體指針類型。

// * persion 返回地址的
func newPerson(name, city string, age int8) *person {
    return &person{
        name: name,
        city: city,
        age:  age,
    }
}

調用構造函數

p9 := newPerson("張三", "ah", 90)
fmt.Printf("%#v\n", p9) //&main.person{name:"張三", city:"ah", age:90}

二、方法和接收者

Go語言中的方法（Method）是一種作用於特定類型變量的函數。這種特定類型變量叫做接收者（Receiver）。接收者的概念就類似於其他語言中的this或者 self。

方法（面向對象中的概念） ：函數和方法

方法有特殊之處，綁定給對象的，在方法內部，可以修改對象

方法的定義格式如下：

func (接收者變量 接收者類型) 方法名(參數列表) (返回參數) {
    函數體
}

其中，

  • 接收者變量：接收者中的參數變量名在命名時，官方建議使用接收者類型名的第一個小寫字母，而不是self、this之類的命名。例如，Person類型的接收者變量應該命名為 p，Connector類型的接收者變量應該命名為c等。
  • 接收者類型：接收者類型和參數類似，可以是指針類型和非指針類型。
  • 方法名、參數列表、返回參數：具體格式與函數定義相同。

舉個例子：

//Person 結構體
type Person struct {
    name string
    age  int8
}

//NewPerson 構造函數
func NewPerson(name string, age int8) *Person {
    return &Person{
        name: name,
        age:  age,
    }
}

//Dream Person做夢的方法
func (p Person) Dream() {
    fmt.Printf("%s的夢想是學好Go語言！\n", p.name)
}

func main() {
    p1 := NewPerson("小王子", 25)
    p1.Dream()
}

方法與函數的區別是， 函數不屬於任何類型， 方法屬於特定的類型。

三、指針類型(接收器)的接收者

指針類型的接收者由一個結構體的指針組成，由於指針的特性，調用方法時修改接收者指針的任意成員變量，在方法結束后，修改都是有效的。這種方式就十分接近於其他語言中面向對象中的this或者self。 例如我們為Person添加一個SetAge方法，來修改實例變量的年齡。

// SetAge 設置p的年齡
// 使用指針接收者
func (p *Person) SetAge(newAge int8) {
    p.age = newAge
}

調用該方法：

func main() {
    p1 := NewPerson("randy", 25)
    fmt.Println(p1.age) // 25
    p1.SetAge(18)
    fmt.Println(p1.age) // 18
}

四、 值類型(接收器)的接收者

當方法作用於值類型接收者時，Go語言會在代碼運行時將接收者的值復制一份。在值類型接收者的方法中可以獲取接收者的成員值，但修改操作只是針對副本，無法修改接收者變量本身。

// SetAge2 設置p的年齡
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
    p.age = newAge
}

func main() {
    p1 := NewPerson("randy", 25)
    p1.Dream()
    fmt.Println(p1.age) // 25
    p1.SetAge2(30) // (*p1).SetAge2(30)
    fmt.Println(p1.age) // 25
}

什么時候應該使用指針類型接收者

  1. 需要修改接收者中的值
  2. 接收者是拷貝代價比較大的大對象
  3. 保證一致性，如果有某個方法使用了指針接收者，那么其他的方法也應該使用指針接收者。

五、匿名字段方法

//5 匿名字段方法

type Hobby1 struct {
	id        int
	hobbyname string
}

type Person4 struct {
	name   string
	age    int
	Hobby1 //匿名字段
}

func (h Hobby1) printName() {
	fmt.Println(h.hobbyname)
}

func main(){
    p :=Person4{"randy",18,Hobby1{1,"籃球"}}

	// 調用打印hobby名字的方法printName
	p.Hobby1.printName()  //大家都想到
	p.printName()   //直接點出來
	

	//面向對的繼承Person4繼承了Hobby1，對象.方法 可以直接用父類的方法
}
  • 面向對的繼承Person4繼承了Hobby1，對象.方法 可以直接用父類的方法

六、任意類型添加方法

在Go語言中，接收者的類型可以是任何類型，不僅僅是結構體，任何類型都可以擁有方法。 舉個例子，我們基於內置的int類型使用type關鍵字可以定義新的自定義類型，然后為我們的自定義類型添加方法。

非結構體上的方法(需要重命名)

//MyInt 將int定義為自定義MyInt類型
type MyInt int

//SayHello 為MyInt添加一個SayHello的方法
func (m MyInt) SayHello() {
    fmt.Println("Hello, 我是一個int。")
}
func main() {
    var m1 MyInt
    m1.SayHello() //Hello, 我是一個int。
    m1 = 100
    fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

非結構體上的方法，想給int 綁定一個add方法，以后每add一次，自加1(int,string,數組，都不能直接綁定方法)，把int8重命名

type Myint int8
func (i *Myint)add()  {
	(*i)++  //自增1
}
	
func main() {
	//想給int 綁定一個add方法，以后每add一次，自加1
	var a Myint=10
	a.add()
	a.add()
	a.add()
	fmt.Println(a)
}

13

注意事項：非本地類型不能定義方法，也就是說我們不能給別的包的類型定義方法。

七、結構體的“繼承”

Go語言中使用結構體也可以實現其他編程語言中面向對象的繼承。

//Animal 動物
type Animal struct {
    name string
}

func (a *Animal) move() {
    fmt.Printf("%s會動！\n", a.name)
}

//Dog 狗
type Dog struct {
    Feet    int8
    *Animal //通過嵌套匿名結構體實現繼承
}

func (d *Dog) wang() {
    fmt.Printf("%s會汪汪汪~\n", d.name)
}

func main() {
    d1 := &Dog{
        Feet: 4,
        Animal: &Animal{ //注意嵌套的是結構體指針
            name: "樂樂",
        },
    }
    d1.wang() //樂樂會汪汪汪~
    d1.move() //樂樂會動！
}

結構體字段的可見性： 結構體中字段大寫開頭表示可公開訪問，小寫表示私有（僅在定義當前結構體的包中可訪問）。

八、 結構體與JSON序列化

JSON(JavaScript Object Notation) 是一種輕量級的數據交換格式。易於人閱讀和編寫。同時也易於機器解析和生成。JSON鍵值對是用來保存JS對象的一種方式，鍵/值對組合中的鍵名寫在前面並用雙引號""包裹，使用冒號:分隔，然后緊接着值；多個鍵值之間使用英文,分隔。

//Student 學生
type Student struct {
    ID     int
    Gender string
    Name   string
}

//Class 班級
type Class struct {
    Title    string
    Students []*Student
}

func main() {
    c := &Class{
        Title:    "101",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i< 10; i++ {
        stu := &Student{
            Name:   fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID:     i,
        }
        c.Students = append(c.Students, stu)
    }
    //JSON序列化：結構體-->JSON格式的字符串
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json:%s\n", data)
    
    
    //JSON反序列化：JSON格式的字符串-->;結構體
    str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
    c1 := &Class{}
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        fmt.Println("json unmarshal failed!")
        return
    }
    fmt.Printf("%#v\n", c1)
}

&{101 [0xc000060360 0xc000060390 0xc0000603c0 0xc0000603f0 0xc000060420 0xc000060450 0xc000060480 0xc0000604b0 0xc0000604e0 0xc000060510]}

json:{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}
&main.Class{Title:"101", Students:[]*main.Student{(*main.Student)(0xc000060870), (*main.Student)(0xc0000608a0), (*main.Student)(0xc0000608d0), (*main.Student)(0xc000060900), (*main.Student)(0xc000060960), (*main.Student)(0xc000060990), (*main.Student)(0xc0000609c0), (*main.Student)(0xc0000609f0), (*main.Student)(0xc000060a20), (*main.Student)(0xc000060a50)}}

8.1 結構體標簽（Tag）

Tag是結構體的元信息，可以在運行的時候通過反射的機制讀取出來。 Tag在結構體字段的后方定義，由一對反引號包裹起來，具體的格式如下：

`key1:"value1" key2:"value2"`

結構體標簽由一個或多個鍵值對組成。鍵與值使用冒號分隔，值用雙引號括起來。鍵值對之間使用一個空格分隔。 注意事項： 為結構體編寫Tag時，必須嚴格遵守鍵值對的規則。結構體標簽的解析代碼的容錯能力很差，一旦格式寫錯，編譯和運行時都不會提示任何錯誤，通過反射也無法正確取值。例如不要在key和value之間添加空格。

例如我們為Student結構體的每個字段定義json序列化時使用的Tag：

//Student 學生
type Student struct {
    ID     int    `json:"id"` //通過指定tag實現json序列化該字段時的key
    Gender string //json序列化是默認使用字段名作為key
    name   string //私有不能被json包訪問
}

func main() {
    s1 := Student{
        ID:     1,
        Gender: "男",
        name:   "沙河娜扎",
    }
    data, err := json.Marshal(s1)
    if err != nil {
        fmt.Println("json marshal failed!")
        return
    }
    fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}

json str:{"id":1,"Gender":"男"} // id變成了小寫，相當於給ID添加字段說明標簽

五、總結

  1. 定義 綁定給結構體的func (p Person)speak(){},speak方法綁定給了Person結構體,使用 p.speak()
  2. 有了函數，為什么要有方法？它跟結構體綁定在一起，使用起來更方便
  3. 值類型接收器和指針類型接收器func (p Person)speak(){} func (p *Person)speak(){} 指針會改變原來的結構體，值的話不會改變原來的結構體
  4. 匿名字段的方法（結構體嵌套了另一個結構體，另一個結構體如果是匿名的，並且綁定了方法），方法會提升（類比：面向對象的繼承）p.另一個結構體的方法() p.另一個結構體.另一個結構體的方法()
  5. 非結構體的方法， 給類型重命名 type 自己的名字 類型 或者可以給自己命名的類型綁定方法
  6. 在方法中使用值接收器和在函數中使用值參數
  7. 在方法中使用指針接收器和在函數中使用值參數
  8. 結構體中字段大寫開頭表示可公開訪問，小寫表示私有（僅在定義當前結構體的包中可訪問）。
  9. JSON序列化:json.Marshal(結構體實例)
  10. JSON反序列化:json.Unmarshal(字符串, 結構體)


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 go中方法的接收者是值或者指針的區別 Flutter學習之Dart語言基礎(構造函數) golang語言構造函數 .NET基礎之構造函數 java基礎42 File類的構造函數及其方法 JAVA基礎——構造函數方法總結（有參構造和無參構造） JAVA構造函數(方法) JAVA構造函數(方法) Object的構造函數方法 JS基礎_構造函數修改
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM