為了物件導向(首先你得有個物件)

method

定義一個method

type Person struct {
    name string
    age int
}

func (p *Person) growup() {  //想想去掉 * 會怎樣?
    p.age += 1
}

func (p Person) getName() string {
    return p.name
}

func (p *Person) setName(name string) {
    p.name = name
}

func main(){
    p := Person{"wq",10}
    println(p, p.name, p.age)
    p.growup()
    println(p.age)
    p.setName("gudqs")
    println(p.name)
}

使用 func ( 方法屬於者 方法屬於者型別) 方法名 (方法引數列表) (返回引數列表) {..}定義一個方法
傳遞 指標型別 使結構體值改變
所有自定義型別, 和一些內建型別均可作為方法屬於者,即可擁有方法

方法繼承

type Person struct {
    name string
    age int
}

type Student struct {
    Person
    no int
    phone string
}

func (p Person) sayhi() {
    println(p.name,p.age)
}

func main(){
    s := Student{Person{"wq",20},1,"110"}
    s.sayhi()
}

利用匿名欄位可繼承改欄位型別的方法 同樣的可以直接呼叫

方法重寫

在之前程式碼 後新增一個 Student 的sayhi方法 , 實現重寫

func (s Student) sayhi() {
    println(s.name,s.no,s.phone,s.age)
}

檢視執行結果, 如果學過java ,你一定已經露出了純潔的笑容     : )

TIP

在方法定義時 , 方法屬於者型別 為一個指標時, 方法種操作 指標不需要 加 *也可, go會自動加
不能為 int , []int 等型別 新增方法, 但通過自定義型別 ,如 type Int int , 則又可以新增方法 ,因此自定義型別具有高擴充套件性啊

interface (介面)

定義介面

type UserDao interface {
    add()
    update()
    remove()
}

使用介面

package main

import f "fmt"

type UserDao interface {
    add(u User)
    update(u User)
    remove(u User)
    findAll() []User
}

type User struct {
    name string
    id int
}   

type UserDaoMysqlImpl struct {
    
}

type UserDaoOracleImpl struct {

}

func (dao UserDaoMysqlImpl) add(u User) {
    f.Println("add user[mysql] :",u)
}

func (dao UserDaoMysqlImpl) update(u User) {
    f.Println("update user[mysql] :",u)
}

func (dao UserDaoMysqlImpl) remove(u User) {
    f.Println("remove user[mysql] :",u.id)
}

func (dao UserDaoOracleImpl) add(u User) {
    f.Println("add user[oralce] :",u)
}

func (dao UserDaoOracleImpl) update(u User) {
    f.Println("update user[oracle] :",u)
}

func (dao UserDaoOracleImpl) remove(u User) {
    f.Println("remove user[oracle] :",u.id)
}

func (dao UserDaoMysqlImpl) findAll() []User {
    users := make([]User,3)
    users[0], users[1], users[2] = User{"wq",1}, User{"aa",2}, User{"gudqs",3}
    return users;
}

func (dao UserDaoOracleImpl) findAll() []User {
    users := make([]User,3)
    users[0] = User{"gg",007}
    return users
}

func main(){
    var dao UserDao
    u := User{"qq",88}
    dao =UserDaoOracleImpl{}
    dao.add(u)
    dao.update(u)
    dao.remove(u)
    for i,u := range dao.findAll() {
        f.Println(i,u)
    }
    dao =UserDaoMysqlImpl{}
    dao.add(u)
    dao.update(u)
    dao.remove(u)
    for j,u2 := range dao.findAll() {
        f.Println("mysql:",j,u2)
    }
}

一個東東 具有 某個介面的所有方法, 那麼這個東東 可以賦值給這個介面型別的變數
這個特性說白了就是類似多型

介面型別 作為函式(方法) 引數

在上面程式碼基礎上新增 如下程式碼:

type UserServiceImpl struct {}

func (service UserServiceImpl) add(u User, dao UserDao) {
    print("service do :")
    dao.add(u)
}

func main(){
    service := UserServiceImpl{}
    u := User{"wq",20}
    dao := UserDaoMysqlImpl{}
    service.add(u,dao)
    dao =UserDaoOracleImpl{}
    service.add(u,dao)
}

新增型別UserServiceImpl和對應的add方法, 使用UserDao作為引數, 然後修改main()

方法引數為介面型別, 好處是 可以接受更多的型別 , 只要那種型別有 這個介面的所有方法

空interface

type a interface {}

func main(){
    var i int = 99
    var str string = "wq"
    a = i
    println(a)
    a = str
    println(str)
}

這樣 a型別 就可以接受任何型別了, 就像 java 的Object型別一樣 !

巢狀 interface

type a interface {
    swap()
    len()
}

type b interface {
    a
    value()
}

然後b就有了 3個方法 , 對的, 想匿名欄位繼承一樣

Comma-ok斷言

type a interface {}

type b struct {
    name string
}

func main(){
    list := make([]a,3)
    a[0] = 1
    a[1] = "wq"
    a[2] = b{"wq"}
    for _,element := range list {
        ok,val := element.(b)
        if ok {
            println(" b is a a")
        }
        ok,val = element.(int)
        if ok {
            println("int is a a")
        }
    }
    //solution 2
    for _,ele := range list {
        switch value :=ele.(type) {
            case int :
                println("ele is an int",)
            case b :
                println("ele is a b")
            default :
                println("ele is default type")
        }
    }
}

通過 變數.(型別) 獲得返回值 ok 判斷 該變數存的是否是 該型別
變數.(type) 僅在switch中 可以使用