4-4 多态、接口和类型断言

package main

//多态：一个父类或接口有多种不同的子类实现。
//接口：只有方法的定义，没有具体的实现，全部是抽象方法。
//实现接口：结构体实现接口的全部抽象方法，就称为结构体实现了接口。

import "fmt"

//劳动者父类接口
//内含两个方法工作和休息
type Worker interface {
    //每天工作多少小时，产出什么产品  对工作定义了方法 参数时间，返回值产品
    Work(hour int) (product string)

    //休息方法
    Rest()
}

type Coder struct {
    skill string
}

func (c *Coder) Work(hour int) (product string) {
    fmt.Printf("码农一天工作%d小时", hour)
    fmt.Printf("码农的技能是%s", c.skill)
    return "BUG"
}

func (c *Coder) Rest() {
    fmt.Printf("休息是什么")
}

func (c *Coder) HomeWork() {
    fmt.Println("在家工作")
}

type ProductManager struct {
    skill string
}

func (pm *ProductManager) Work(hour int) (product string) {
    fmt.Printf("码农一天工作%d小时", hour)
    fmt.Printf("码农的技能是%s", pm.skill)
    return "无逻辑的需求"
}

func (pm *ProductManager) Rest() {
    fmt.Println("看程序员写代码")
}

type Boss struct {
    skill string
}

func (b *Boss) Work(hour int) (product string) {
    fmt.Printf("老板一天工作了%d小时", hour)
    fmt.Printf("老板的技能是%s", b.skill)
    return "梦想"
}

func (b *Boss) Rest() {
    fmt.Printf("从早到晚休息")
}

func main() {
    //创建有worker组成的切片
    workers := make([]Worker, 0)

    workers = append(workers, &Coder{"写代码"})
    workers = append(workers, &ProductManager{"拍脑门"})
    workers = append(workers, &Boss{"吹牛逼"})

    //类型断言，判断接口的类型
    //有两种方式 一种方式更范围更广
    for _, worker := range workers {
        switch worker.(type) {
        case *Coder:
            fmt.Println("人家是写代码的")
        case *ProductManager:
            fmt.Println("人家是搞创意的")
        case *Boss:
            fmt.Println("我是给员工打工的")
        default:
            fmt.Println("不清楚是什么东西")

        }
    }

    //粒度更细点
    for _, workers := range workers {
        if coder, ok := workers.(*Coder); ok {
            fmt.Println("我是写代码的")
            coder.HomeWork()
        }
    }
}