Go Interface概念

简单地说 Interface是一组Method的组合，可以通过Interface来定义对象的一组行为。
如果某个对象实现了某个接口的所有方法，就表示它实现了该借口，无需显式地在该类型上添加接口说明。Interface是一个方法的集合，它里面没有其他类型变量，而且Method只用定义原型 不用实现

 

实现一个动物的接口：

package main

import "fmt"

// 定义一个 Animal接口
type Animal interface {
    Eat()
    Talk()
    Run()
}


// Dog 实现了Animal的所有方法，就可以说Dog实现了Animal这个接口
type Dog struct {
    name string
}

func (d *Dog) Eat() {
    fmt.Printf("%s is Eating...\n", d.name)
}

func (d *Dog) Talk() {
    fmt.Printf("%s is Talking...\n", d.name)
}

func (d *Dog) Run() {
    fmt.Printf("%s is Running...\n", d.name)
}

func main() {
    var dog = &Dog{
        name: "WangCai",
    }

    var a Animal
    a = dog
    a.Run()
    a.Eat()
    a.Talk()
}

 

实现一个雇员的接口

package main

import "fmt"

type Employee interface {
    Calc() float32
}

type Developer struct {
    Name string
    Base float32
}

func (d *Developer) Calc() float32 {
    return d.Base
}

type PM struct {
    Name string
    Base float32
    Option float32
}

func (p *PM) Calc() float32 {
    return p.Base * p.Option
}

type Operation struct {
    Name string
    Base float32
    Option float32
    Ratio float32 // 0.5 - 3
}

func (o *Operation) Calc() float32 {
    return o.Base * o.Option * o.Ratio
}


type EmployeeMgr struct {
    employeeList []Employee
}

func (e *EmployeeMgr) Calc() float32 {
    var sum float32
    for _, v := range e.employeeList {
        sum += v.Calc()
    }
    return sum
}

func (e *EmployeeMgr) AddEmployee(d Employee) {
    e.employeeList = append(e.employeeList, d)
}

func main() {
    var e = &EmployeeMgr{}

    dev := &Developer{
        Name: "alex",
        Base: 10000,
    }
    e.AddEmployee(dev)

    pm := &PM{
        Name: "Jim",
        Base: 10000,
        Option: 12000,
    }
    e.AddEmployee(pm)

    oper := &Operation{
        Name: "Miles",
        Base: 10000,
        Option: 12000,
        Ratio: 1.2,
    }
    e.AddEmployee(oper)

    sum := e.Calc()

    fmt.Printf("the sum is: %f", sum)
}

 

实现error interface

// builtin.go 中的error interface

type error interface {
    Error() string
}

package main

import (
    "time"
    "fmt"
)

type MyError struct {
    When time.Time
    What string
}


// MyError实现了 Error 这个方法，也就实现了error interface
func (e MyError) Error() string {
    str := fmt.Sprintf("at %v, %s", e.When, e.What)
    return str
}

// 直接返回MyError对象
func run() error {
    myError := MyError{time.Now(), "it didn't work"}
    return myError
}

func main() {
    if err := run(); err != nil {
        fmt.Println(err)
    }
}