Go：一文玩转接口

接口的基本剖析

package main

import "fmt"

type Test interface {
 show()
}

type myString string

func (mys myString) show() {
 fmt.Println(mys)
}

func main() {
 var a myString = "tantianran"
 a.show()
}

输出：

tantianran

定义接口：上述代码中，定义了接口Test，该接口规定了有show()方法，而且，Test接口只有1个方法。

实现接口：接下来就是实现接口，在go中，任意类型只要实现了接口的所有方法（这里的Test接口只有1个方法），那么就实现了该接口（而且是隐式实现），刚提到任意类型，于是这里定义了一个类型为string的自定义类型myString，且由该自定义类型myString实现了show()方法，刚提到只要实现了接口的所有方法就实现了该接口，也就是说自定义的myString类型已经实现了Test接口。

使用接口：定义了类型为myString的变量a，且给它赋值了”tantianran”，这时候，它就拥有了show方法。所以说，一个变量不管它是什么类型，只要实现了Test接口，就能调用它的show方法。

在上一个栗子的基础上，继续看看这个小栗子

刚提到任意类型只要实现了Test接口，就能调用它的show方法，来验证一下

package main

import "fmt"

type Test interface {
 show()
}

type myInts int16

func (myi myInts) show() {
 fmt.Println(myi)
}

func main() {
 var a myInts = 200
 a.show()
}

输出：

果然，自定义了一个int16类型的自定义类型myInts，它也用了show方法。

继续上一个例子，看看下面代码

定义个结构体类型的User试试

package main

import "fmt"

type Test interface {
 show()
}

type User struct {
 name string
 age  int
}

func (u User) show() {
 fmt.Println(u)
}

func main() {
 u := User{"tantianran", 18}
 u.show()
}

输出：

{tantianran 18}

来一个贴近生活的小栗子

package main

import "fmt"

// 支付接口
type Payment interface {
 Payment() float64
}

// 银行卡
type Bankcard struct {
 CardId     int64
 Moneytotal float64
}

// 结算
func settleAccount(b *Bankcard, p Payment) {
 fmt.Println("正在发生扣款...")
 amount := p.Payment()
 res := b.Moneytotal - amount
 b.Moneytotal = res
}

// 微信
type Weixin struct {
 AccountID string
 Type      string
}

func (w Weixin) Payment() float64 {
 return 65.78
}

// 支付宝
type Zhifubao struct {
 AccountID string
 Type      string
}

func (z Zhifubao) Payment() float64 {
 return 82.12
}

type PingDuoduo struct {
 Commodity string  //商品
 Price     float64 //价格
}

func main() {
 card := Bankcard{CardId: 2349342594759947742, Moneytotal: 1200.89}
 fmt.Println(card.Moneytotal)
 wx := Weixin{AccountID: "ttr", Type: "微信"}
 zfb := Zhifubao{AccountID: "ttr1", Type: "支付宝"}
 settleAccount(&card, wx)
 settleAccount(&card, zfb)

 fmt.Println(card.Moneytotal)

}

通过接口实现结构体排序

自定义的结构体只要实现了Len、Less、Swap方法，就可以交给标准库中的sort.Sort进行排序。

package main

import (
 "fmt"
 "math/rand"
 "sort"
)

type Hero struct {
 Name string
 Age  int
}

type HeroSlice []Hero

func (hs HeroSlice) Len() int {
 return len(hs)
}

func (hs HeroSlice) Less(i, j int) bool {
 return hs[i].Age < hs[j].Age
}

func (hs HeroSlice) Swap(i, j int) {
 temp := hs[i]
 hs[i] = hs[j]
 hs[j] = temp
}

func main() {
 var heroes HeroSlice
 for i := 0; i < 10; i++ {
  hero := Hero{
   Name: fmt.Sprintf("host-%d", rand.Intn(100)),
   Age:  rand.Intn(100),
  }
  heroes = append(heroes, hero)
 }

 sort.Sort(heroes)
 for _, v := range heroes {
  fmt.Println(v)
 }
}

函数形参，类型是空接口时可以接收任意类型

package main

import "fmt"

func test(t interface{}) {
 fmt.Println(t)
}

type User struct {
 name string
}

func main() {
 a := 1
 b := "hello"
 c := map[string]int{
  "age": 18,
 }
 u := User{name: "ttr"}

 z := []interface{}{"hello", 100, 89.78, c, a, b}

 test(a)
 test(b)
 test(c)
 test(u)

 test(z)
}

变量的类型为空接口时，也可以接收任意类型的值

package main

import "fmt"

type myinterface interface{}

func main() {
 var a myinterface = 10
 fmt.Println(a)
 var b myinterface = 89.78
 fmt.Println(b)

 numarr := []int{1, 2, 3, 4, 5}
 var c myinterface = numarr
 fmt.Println(c)

 user := map[string]string{
  "name": "ttr",
  "addr": "gz",
 }
 var d myinterface = user
 fmt.Println(d)
}