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)
}