为了面向对象(首先你得有个对象)

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中 可以使用