接口与多态

何为接口

  在面向对象的领域里，接口一般这样定义：接口定义一个对象的行为。接口只指定了对象应该做什么，至于如何实现这个行为（即实现细节），则由对象本身去确定。
  在 Go 语言中，接口就是方法签名（Method Signature）的集合。当一个类型定义了接口中的所有方法，我们称它实现了该接口。接口指定了一个类型应该具有的方法，并由该类型决定如何实现这些方法。

接口定义

  使用type关键字来定义接口
如下所示，定义了一个叫order的接口，接口要求必须实现printName方法

type order interface{printName()
}

接口的实现

如果有一个类型/结构体，实现了一个接口要求的所有方法，我们就可以称它实现了该接口。

接口实现多态

  一个接口，在不同对象上的不同表现。这就是多态。在 Go 语言中，是通过接口来实现的多态。

package mainimport ("fmt""strconv"
)//定义一个接口
type order interface{countmoney() intpaymoney() string
}type hamburger struct{name stringquantity intprice int
}func (ham hamburger) countmoney() (int){return ham.quantity*ham.price
}func (ham hamburger) paymoney() (string){//strconv.Itoa() 可以将数字转换成对应的字符串类型的数字。return "所购买的" + strconv.Itoa(ham.quantity) + "个"+ham.name+"共计：" + strconv.Itoa(ham.countmoney()) + "元" 
}type roastrice struct{name stringquantity int  price int
}func (roa roastrice) countmoney() (int){return roa.quantity*roa.price
}func (roa roastrice) paymoney() (string){return "所购买的" + strconv.Itoa(roa.quantity) + "个"+roa.name+"共计：" + strconv.Itoa(roa.countmoney()) + "元" 
}func calaulateSum(orders []order)(int){var sumPrice intfor _,now := range orders{fmt.Println(now.paymoney())sumPrice += now.countmoney()}return sumPrice
}func main(){ham := hamburger{"烤鸡汉堡",2,18,}rice := roastrice{"烤饭",5,2,}orders := []order{ham,rice}sumPrice := calaulateSum(orders)fmt.Printf("这顿饭共计%d元",sumPrice)
}

接口使用的注意事项

1.方法调用的限制

接口是一组固定的方法集，由于静态类型的限制，接口变量有时仅能调用其中特定的一些方法。
下面这段代码会报错

type Phone interface{call()
}type iPhone struct{name string
}func (ipone iPhone) call(){fmt.Println("Hello iPhone.")
}func (iphone iPhone) send_wechat(){fmt.Println("Hello Wechat")
}func main(){var phone Phonephone = iPhone{"xin's iphone"}phone.call()phone.send_wechat()
}

提示我们 Phone 类型的方法没有 send_wechat 的字段或方法。

原因也很明显，因为我们的phone对象显式声明为 Phone 接口类型，因此 phone调用的方法会受到此接口的限制。
修改方法：隐式实现 Phone 接口，如此一来，方法的调用就不会受到接口类型的约束。

	/* var phone Phonephone = iPhone{"xin's iphone"} */phone := iPhone{"xin's iphone"}phone.call()phone.send_wechat()

2.调用函数时的隐式转换

Golang 语言中的函数调用都是值传递的，变量会在方法调用前进行类型转换。
eg:下面一段是可以正常运行的代码

func printTpe(i interface{}){switch i.(type){case int:fmt.Println("参数的类型是 int")case string:fmt.Println("参数的类型是 string")}
}func main(){a:=10printTpe(a)
}

但是如果你把函数内的内容搬到到外面来

func main(){a:=10switch a.(type){case int:fmt.Println("参数的类型是 int")case string:fmt.Println("参数的类型是 string")}
}

报错：

当一个函数接口 interface{} 空接口类型时，我们说它可以接收什么任意类型的参数（江湖上称之为无招胜有招）。就是把传入函数的参数值（注意：Go 语言中的函数调用都是值传递的）的类型隐式的转换成 interface{} 类型。
所以要想不通过接收空接口类型的函数进行类型判断，我们需要进行显示转换

func main(){a:=10switch interface{}(a).(type){case int:fmt.Println("参数的类型是 int")case string:fmt.Println("参数的类型是 string")}
}