interface 是一種類型设褐，從它的定義可以看出來用了 type 關鍵字屹蚊，更準確的說 interface 是一種具有一組方法的類型，這些方法定義了 interface 的行為。
簡單的說挺举，interface是一組method簽名的組合，我們通過interface來定義對象的一組行為烘跺。golang是通過 interface 類型接口實現(xiàn)的繼承多態(tài)的效果湘纵。
go 允許不帶任何方法的 interface ，這種類型的 interface 叫 empty interface滤淳。
如果一個類型實現(xiàn)了一個 interface 中所有方法梧喷，我們說類型實現(xiàn)了該 interface，所以所有類型都實現(xiàn)了 empty interface，因為任何一種類型至少實現(xiàn)了 0 個方法铺敌。go 沒有顯式的關鍵字用來實現(xiàn) interface汇歹，只需要實現(xiàn) interface 包含的方法即可。
廢話不多說偿凭。上代碼产弹，請注意下面的兩種寫法：
package main
import "fmt"
// 這是一個接口
type Animal interface {
bark()//聲明一個方法
}
//結構體
type Dog struct {
name string
}
func (dog *Dog) bark() {
fmt.Printf("名字為%s的小狗在叫\(zhòng)n", dog.name)
}
type Pig struct {
name string
}
func (pig *Pig) bark() {
fmt.Printf("名字為%s的小豬在叫\(zhòng)n", pig.name)
}
func bark11(animal Animal) {
animal.bark()
}
func main() {
dog := Dog{"旺財"}
pig := Pig{"豬八戒"}
bark11(&dog)
bark11(&pig)
}
輸出為：
名字為旺財?shù)男」吩诮?名字為豬八戒的小豬在叫
package main
import "fmt"
// 這是一個接口
type Animal interface {
bark()
}
type Dog struct {
name string
}
func (dog Dog) bark() {
fmt.Printf("名字為%s的小狗在叫\(zhòng)n", dog.name)
}
type Pig struct {
name string
}
func (pig Pig) bark() {
fmt.Printf("名字為%s的小豬在叫\(zhòng)n", pig.name)
}
func bark11(animal Animal) {
animal.bark()
}
func main() {
dog := Dog{"旺財"}
pig := Pig{"豬八戒"}
bark11(dog)
bark11(pig)
}
輸出為：
名字為旺財?shù)男」吩诮?名字為豬八戒的小豬在叫
這兩種寫法關系到指針的的用法，后面會詳細講解
下面再通過一個簡單的案例弯囊，講解interface的使用過程
//1
type I interface {
Get() int
Set(int)
}
//2
type S struct {
Age int
}
func(s S) Get()int {
return s.Age
}
func(s *S) Set(age int) {
s.Age = age
}
//3
func f(i I){
i.Set(10)
fmt.Println(i.Get())
}
func main() {
s := S{}
f(&s) //4
}
這段代碼在 #1 定義了 interface I痰哨，在 #2 用 struct S 實現(xiàn)了 I 定義的兩個方法，接著在 #3 定義了一個函數(shù) f 參數(shù)類型是 I匾嘱，S 實現(xiàn)了 I 的兩個方法就說 S 是 I 的實現(xiàn)者斤斧，執(zhí)行 f(&s) 就完了一次 interface 類型的使用。
interface 的重要用途就體現(xiàn)在函數(shù) f 的參數(shù)中奄毡，如果有多種類型實現(xiàn)了某個 interface折欠，這些類型的值都可以直接使用 interface 的變量存儲。
s := S{}
var i I //聲明 i
i = &s //賦值 s 到 i
fmt.Println(i.Get())
不難看出 interface 的變量中存儲的是實現(xiàn)了 interface 的類型的對象值吼过，這種能力是 duck typing锐秦。在使用 interface 時不需要顯式在 struct 上聲明要實現(xiàn)哪個 interface ，只需要實現(xiàn)對應 interface 中的方法即可盗忱，go 會自動進行 interface 的檢查酱床，并在運行時執(zhí)行從其他類型到 interface 的自動轉換，即使實現(xiàn)了多個 interface趟佃，go 也會在使用對應 interface 時實現(xiàn)自動轉換扇谣，這就是 interface 的魔力所在。
empty interface
interface{} 是一個空的 interface 類型闲昭，根據(jù)前文的定義：一個類型如果實現(xiàn)了一個 interface 的所有方法就說該類型實現(xiàn)了這個 interface罐寨，空的 interface 沒有方法，所以可以認為所有的類型都實現(xiàn)了 interface{}序矩。
package main
import "fmt"
type Animal interface{}
type Dog struct {
age int
}
type Cat struct {
weigth float64
}
func main() {
dog := Dog{18}
cat := Cat{300}
dog1 := Dog{17}
cat1 := Cat{301}
animals := []Animal{dog, cat, dog1, cat1}
fmt.Println(animals)
}
輸出為：
[{18} {300} {17} {301}]
如果定義一個函數(shù)參數(shù)是 interface{} 類型鸯绿，這個函數(shù)應該可以接受任何類型作為它的參數(shù)。
package main
import "fmt"
type Sq struct {
l float64
}
func (sq Sq) area() float64 {
return sq.l * sq.l
}
type Circle struct {
r float64
}
func (c Circle) area() float64 {
return 3.14 * c.r * c.r
}
// 接收任何的參數(shù),但是意義不是特別大
func info(v interface{}) {
fmt.Println(v)
}
func main() {
sq := Sq{80.0}
sq1 := Sq{80.0}
sq2 := Sq{80.0}
c := Circle{35.5}
info(sq)
animals := []interface{}{sq, sq1, sq2, c}
fmt.Println(animals)
}
輸出為：
{80}
[{80} {80} {80} {35.5}]
最后附一題(解題思路很好)
寫一個父類把三個類中相同的屬性替換掉簸淀。
創(chuàng)建4個dog瓶蝴，3個Cat，2個pig對象租幕，將他們亂序裝到一個數(shù)組里面
寫一個方法舷手，animals.sort(1) //1 或者 0，如果是1劲绪，按姓名排序男窟，如果是0盆赤，按年齡排序
package main
import (
"fmt"
"strings"
)
// 接口是用來寫共同的方法的
type sortInterFace interface {
sortname() string
sortage() int
}
type ids struct {
name string
age int
}
// 貓
type cat struct {
ids
}
func (cat cat) sortname() string {
return cat.name
}
func (cat cat) sortage() int {
return cat.age
}
//狗
type dog struct {
ids
}
func (dog dog) sortname() string {
return dog.name
}
func (dog dog) sortage() int {
return dog.age
}
// 豬
type pig struct {
ids
}
func (pig pig) sortname() string {
return pig.name
}
func (pig pig) sortage() int {
return pig.age
}
//主函數(shù)
func main() {
testids()
}
func testids() {
dog1 := dog{ids{"aehe1", 10}}
dog2 := dog{ids{"hehe12", 131}}
dog3 := dog{ids{"behe13", 132}}
dog4 := dog{ids{"jehe14", 133}}
//cat
cat1 := cat{ids{"cat12", 11}}
cat2 := cat{ids{"cat13", 12}}
cat3 := cat{ids{"cat14", 13}}
//pig
pig1 := pig{ids{"pig1", 102}}
pig2 := pig{ids{"pig2", 103}}
// 裝入到一個數(shù)組當中
ids2 := []sortInterFace{dog1, dog2, dog3, dog4, cat1, cat2, cat3, pig1, pig2}
fmt.Println(ids2)
// 1,按年齡排序.. 0,按姓名排序
// ids2 = sort(ids2... ,0)
ids2 = sort(ids2, 0)
// 打印結果
for i := 0; i < len(ids2); i++ {
fmt.Println("==== 排序后%v", ids2[i])
}
}
func sort(nums []sortInterFace, num int) []sortInterFace {
switch {
case num == 1:
return sortByAge(nums)
case num == 0:
return sortByName(nums)
default:
return nums
}
}
// 如果等于1按age排序
func sortByAge(idss []sortInterFace) []sortInterFace {
for i := 0; i < len(idss)-1; i++ {
for j := 0; j < len(idss)-1-i; j++ {
//后面的最小
if idss[j].sortage() > idss[j+1].sortage() {
idss[j], idss[j+1] = idss[j+1], idss[j]
}
}
}
return idss
}
// 如果等于0按姓名排序
func sortByName(idss []sortInterFace) []sortInterFace {
for i := 0; i < len(idss)-1; i++ {
for j := 0; j < len(idss)-1-i; j++ {
//后面的最小 Compare(a, b string) int
// 前面的大
if strings.Compare(idss[j].sortname(), idss[j+1].sortname()) > 0 {
idss[j], idss[j+1] = idss[j+1], idss[j]
}
}
}
return idss
}
