Go語言之method

方法method

• Go 中雖沒有class, 但依舊有method
• 經過顯示說明receiver來實現與某個類型的組合
• 只能爲同一個包中的類型定義方法
• receiver能夠是類型的值或指針
• 不存在方法重載
• 可使用值或者指針來調用方法，編譯器會自動完成轉換
• 從某種意義上來講，方法是函數的語法糖，由於receiver其實就是方法所接收的第一個參數(Method Value vs. Method Express)
• 若是外部結構和嵌入結構存在同名方法，則優先調用外部結構的方法
• 類型別名不會擁有底層類型所附帶的方法
• 方法能夠調用結構中的非公開字段

---

一、建立method

//建立方法
package main

import "fmt"

type book struct {
    Name string
}

type eleBook struct {
    Name string
}

func main() {
    //建立一個對象
    aBook := book{Name:"spark computer"}
    aBook.show()

    bBook := eleBook{Name:"k8s computer"}
    bBook.show()
}

//建立一個method
//此mothod方法屬於book類型
//(a book)  這個字段 是說
// 此方法，屬於哪類型，是跟類型綁定的
// (a book)就是一個receiver
//只能指定的類型的變量，才能調用
//方法的綁定，只能是同一個包中，才起做用
func (a book) show()  {
    fmt.Println("this is book:\t",a.Name)
}

// 這屬於重載了
//func (a book) show(info string)  {
//  fmt.Println("this is book")
//}

//建立一個method
//此mothod方法屬於eleBook類型
func (a eleBook) show()  {
    fmt.Println("this is ele book")
}

---

二、receiver 按引用傳遞 測試

package main

import "fmt"

type flower struct {
    Name string
}

type rose struct {
    Name string
}

func main() {

    flower := flower{Name:"a big flower"}
    rose := rose{Name:"a big rose"}
    fmt.Println("init flower:\t", flower)
    flower.show()
    fmt.Println("after flower:\t", flower)

    fmt.Println("===========================")

    fmt.Println("init rose:\t", rose)
    rose.show()
    fmt.Println("after rose:\t", rose)
}

//(flower flower)  這種方式，是按值傳遞的，不能改變原值的
func (flower flower)show()  {
    flower.Name = "I'm flower"
    fmt.Println("flower:\t", flower)
}

//(rose *rose) 是按引用傳遞的，能夠改變原值的
func (rose *rose)show()  {
    rose.Name = " this is rose"
    fmt.Println("rose:\t", rose)
}

---

三、測試 別名 與 方法的綁定

//別名 與 方法的綁定
// 做用，就是，有一種加強的感受，如int類型，自己沒有show,add方法
//別名  與   方法的組合，確有了
package main

import "fmt"

type TZ int

func main() {
    var ty TZ = 3
    fmt.Println("ty:\t" , ty)
    //Method value 調用方式，經過類型的變量來調用
    ty.show()
    ty.add()

    fmt.Println("==================Method value   Method Express的不一樣==============================")
    //對方法的兩種不一樣的導調用方式而已

    //Method express 調用方式，經過類型直接來調用
    //此種方式，須要本身輸入 變量
    //由於receiver接收的是地址，所以，咱們傳入的是地址
    (*TZ).show(&ty)
    (*TZ).add(&ty)

}

//下面的這些方法，都是經過 某一個類型的 變量 來進行調用的
//java 是經過對象來調用的
func (tz *TZ)show()  {
    fmt.Println("---->:\t 這是int類型", *tz) //tz是地址，*tz 是取地址裏的內容了
}

func (tz *TZ)add()  {
    fmt.Println("---->:\t 這是int類型的加法")
}

---

四、方法訪問屬性 的權限 測試

//方法 的權限問題，是否能夠訪問 私有字段呢？
//權限是以package 爲級別的
//方法的訪問權限是很高的，能夠訪問同一個package下的全部屬性，包括公共的，私有的
package main

import "fmt"

type bike struct {
    //小寫是私有屬性，私有屬性，只能在同一個package內，進行訪問的
    name string
    //大寫是公共屬性
    Color string
}

func main() {
    bike := bike{name:"捷安特", Color:"黑色"}
    fmt.Println("old bike:\t", bike)

    //經過類型的變量，來調用方法
    bike.show()
    fmt.Println("new bike:\t", bike)
}

func (bike *bike)show()  {
    bike.Color = "紅色"
    bike.name = "永久" //看見了吧，方法是能夠訪問同一package下的私有屬性的
    fmt.Println("bike:\t", bike)
}

---

五、練習題

//練習題：
//依據的理論知識：爲結構增長方法的知識
//嘗試聲明一個底層類型爲int的類型
//並實現調用某個方法就遞增100
//如   a:=0, 調用a.Increase()只會，a從0變成100
package main

import "fmt"

//爲int 聲明一個別名
type intFor int

func main() {
    var a intFor = 0
    fmt.Println(a.Increase())
}

//傳的地址
//注意，返回值的類型是intFor
func (arg *intFor)Increase()  intFor {
    //添加上*,就表示取地址裏的內容了
    *arg = 100

    return *arg
}

---

總結：

例如，type intFor int，
不光是int類型，也能夠是其餘類型。
開始擴展思惟，其實，就是爲某個類型，增長方法；
Java裏的一個類裏包括屬性，以及方法；
在Go語言中，各類屬性是封裝在一個類型裏，方法是經過receiver來綁定；
只是不一樣的表現形式而已