9. 面向对象

type

给类型起别名 相当于 C的typedef

package main
import "fmt"
func main() {
    // 给类型起别名
    // type 类型名 类型
    type INT int
    var a INT
    fmt.Println(a)
}

定义结构体

package main
import "fmt"
type Person struct {
    name string
    age int
}
func main() {
    var p Person
    p.name="JackMa"
    p.age=56
    fmt.Printf("%+v",p)
}

{name:JackMa age:56}

封装

package main
import "fmt"
type Person struct {
    name string
    age int
}
// 当前this是对象的拷贝
func (this Person)print()  {
    fmt.Printf("%#v\n",this)
}
// 如果需要修改值则需要指针
func (this *Person)setValue(name string)  {
    this.name=name
}
func main() {
    var p Person
    p.name="JackMa"
    p.age=56
    fmt.Printf("%+v\n",p)
    p.print()
    p.setValue("aaaa")
    p.print()
}

{name:JackMa age:56}
main.Person{name:"JackMa", age:56}
main.Person{name:"aaaa", age:56}

继承

package main
import (
    "fmt"
    "reflect"
)
type Animal struct {
}
func (this *Animal)Eat()  {
    fmt.Printf("Obj:%v Eat\n",reflect.TypeOf(this))
}
func (this *Animal)Drink()  {
    fmt.Printf("Obj:%v Drink\n",reflect.TypeOf(this))
}
type Dog struct {
    // 自动继承 Animal的所有方法
    Animal
}
// 重写父类方法
func (this *Dog)Eat()  {
    fmt.Printf("Obj:%v Eat\n",reflect.TypeOf(this))
}
func main() {
    // 创建一个子类对象
    dog :=Dog{Animal{}}
    // 子类方法
    dog.Eat()
    // 父类方法
    dog.Drink()
}

Obj:*main.Dog Eat
Obj:*main.Animal Drink

多态

• 接口本质上就是一个指针
• 如果一个类包含接口的所有方法则默认实现该接口
• 使用接口实现多态（父对象指针指向子对象）

package main
import (
    "fmt"
    "reflect"
)
// 定义一个接口
type Pen interface {
    Write()
    GetColor() string
}
// 一个类实现 interface 中所有方法则自动实现这个接口
type Pencil struct {
    color string
}
func (this *Pencil) GetColor() string {
    return this.color
}
func (this *Pencil) Write() {
    fmt.Printf("Obj:%v Write\n", reflect.TypeOf(this))
}
// 一个类实现 interface 中所有方法则自动实现这个接口
type Chalk struct {
    color string
}
func (this *Chalk) GetColor() string {
    return this.color
}
func (this *Chalk) Write() {
    fmt.Printf("Obj:%v Write\n", reflect.TypeOf(this))
}
func write(pen Pen) {
    pen.Write()
}
func main() {
    /*
        // 父类接口 本质上是一个指针
        var pen Pen
        pen= &Pencil{"red"}
        write(pen)
        write(&Chalk{"white"})
    */
    pencil:=Pencil{"red"}
    chalk:=Chalk{"white"}
    write(&pencil)
    write(&chalk)
}

Obj:*main.Pencil Write
Obj:*main.Chalk Write