go中interface实现多态

package main

import "fmt"

//go语言使用了隐式继承
//定义接口时只有两种类型，一种时空接口，一种是有方法的
//go语言中使用interface实现了多态
//空接口类型

type Masida interface{}

type People interface {
    Jiao()
}

//不能给接口定义方法
//func (p *People)Say()  {
//  fmt.Println("interface People method Say....... ")
//}

//可以给int类型做一个别名叫Animal，只在当前包使用；
type Animal int

//Animal这个类型别名可以有方法
func (a *Animal) Jiao() {
    fmt.Println("type111111 alias have a method Jiao().....")
}

type Animal1 string

//Animal这个类型别名可以有方法
func (a1 *Animal1) Jiao() {
    fmt.Println("type222222 alias have a method Jiao().....")
}

type Animal2 struct{}

//Animal这个类型别名可以有方法
func (a2 *Animal2) Jiao() {
    fmt.Println("type333333 alias have a method Jiao().....")
}

type Animal3 struct {
}

//Animal这个类型别名可以有方法
func (a3 *Animal3) Jiao() {
    fmt.Println("type444444 alias have a method Jiao().....")
}

func main() {
    var p0 People
    p0 = new(Animal)
    p0.Jiao()
    p0 = new(Animal1)
    p0.Jiao()
    p0 = &Animal2{}
    p0.Jiao()
    p0 = &Animal3{}
    p0.Jiao()

    //或者用以下方式
    fmt.Println("--------------------")
    PeopleJiao(new(Animal)) //丢不同的对象进去
    PeopleJiao(new(Animal1))
    PeopleJiao(new(Animal2))
    PeopleJiao(new(Animal3))
    fmt.Println("--------------------")

    var m1 Masida
    fmt.Println(m1 == nil)
    fmt.Printf("type is: %T\n", m1)
    m1 = 0
    fmt.Println(m1 == nil)
    fmt.Printf("type is: %T\n", m1)
    m1 = struct{}{}
    fmt.Println(m1 == nil, m1)
    fmt.Printf("type is: %T\n", m1)
    m1 = nil
    fmt.Println(m1 == nil, m1)
    fmt.Printf("type is: %T\n", m1)
}

//基于抽象层进行业务封装
func PeopleJiao(people People) { //相当于 var people People = new(Animal)
    people.Jiao() //调用响应子类对象的方法
}

面向对象思想中的多态特性在go中的基本实现； 这里顺便介绍一个设计模式中的原则：依赖倒转原则。

• 业务层-->抽象层<--实现层
• 业务层：不直接与实现层交互，与抽象层交互。
• 抽象层:就是我们的interface,定义了一系列的方法
• 实现层：子类中的具体实现；实现抽象层的所有方法