go--面向对象式编程

go语言没有对象的概念，但是struct类型有着和对象类似的特性。struct类型可以定义自己的属性和方法。然后可以实现继承和多态这些概念

嵌入类型

因为go语言没有继承，所以可以通过组合的方式来实现代码的方式。
嵌入类型是指将已有的类型直接声明在新的结构类型里。

type User struct{
    Name string
    Email string
}

type Admin struct{
    User                     //匿名成员，类型即名称
    Level string
}

func (u *User) Speak(){
    fmt.Println("I am user", u.Name)
}

上面User类型嵌入到Admin类型中，也可以称Admin为外部类型，User为内部类型
通过嵌入，内部类型的属性、方法，可以为外部类型所有，就好像是外部类型自己的一样。

考点1

• 外部类型也可以定义自己的属性和方法，甚至可以定义与内部类型一样的方法，这样一来，内部类型的方法就会被屏蔽

admin := Admin{
        User:User{
               Name: "Jack",
               Email: "[email protected]"
        }
        Level: "admin"
    }
    //方式1：内部类型的方法会提升到外部类型，可通过外部类型直接访问
    admin.Speak()
    //方式2：直接访问内部类型的方法
    admin.User.Speak()

输出

I am user Jack
I am user Jack

如果Admin也定义了Speak()方法

func (a *Admin) Speak(){
    fmt.Println("I am admin", a.Name)
}

然后再调用

 //方式1：会被外部类型的方法覆盖
admin.Speak()
//方式2：直接访问内部类型的方法
admin.User.Speak()

输出

I am user admin
I am user Jack

考点2

如果内部类型实现了接口A，也可以认为外部类型也实现了接口A
通过实现接口可以实现多态特性

例子1

//定义一个接口，接口有speak()方法
type Speaker interface{
    Speak()
}

//如果把实现过接口的类型传入到gotoSpeak函数中，就会调用类型自己的speak()方法
func gotoSpeak(s Speaker){
    s.Speak()
}

在User实现了Speak()方法，而Admin没有实现Speak()方法的情况下

gotoSpeak(&admin)

输出：

I am user Jack

注意：给gotoSpeak()传的参数是admin的地址，类型是Admin, 不能传Admin类型的值。这里Admin并没有实现Speak()函数，也就是说Admin并没有实现Speaker接口。但是能够通过传Admin的类型调到内部类型的函数。

例子2

type Admin struct{
    *User
    Level string
}

gotoSpeak(&admin)   //I am user Jack
gotoSpeak(admin)     //I am user Jack

注意： 这里既可以传admin的值，也可以传admin的地址，因为内置类型是*User类型

由此我们可以得到一下总结：
假设外部结构体类型是S， 内部类型是T

• 1. T嵌入S，外部类型S可以通过值类型或者指针类型调用内部类型T的值方法
• 2. T嵌入S，外部类型S只能通过指针类型调用内部类型T的指针方法
• 3. *T嵌入S，外部类型S可以通过值类型和指针类型调用内部类型T的值方法和指针方法

附录

值方法与指针方法

// 值接收者
func (u user) notify() {
    log.Printf("sending User Email to %s<%s>\n", u.name, u.email)
}

// 引用接收者
func (u *user) notifyPointer() {
    log.Printf("sending User Email to %s<%s>\n", u.name, u.email)
}

多态

通过父类就能够引用不同的子类，只有在运行的时候才会知道引用变量所指向的具体实例对象

遗留问题

如果多个内置类实现了同一个接口，传入父类，调用的是哪个呢？