本文以Golang的接口实现为例，为大家分析Golang接口功能与作用。阅读完整文相信大家对Golang的接口有了一定的认识。
创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都做网站、成都网站设计、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的黔西网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！在Go语言中，接口(interface)是一种类型，一种抽象的类型。
interface是一组method的集合，是duck-type programming的一种体现。
接口做的事情就像是定义一个协议(规则)，只要一台机器有洗衣服和甩干的功能，就是洗衣机。不关心属性(数据)，只关心行为(方法)。
在Java中，也是有接口的概念的。package main
import "fmt"
type Cat struct {}
func (c Cat) say() string {
return "喵喵喵"
}
type Dog struct {}
func (d Dog) say() string {
return "汪汪汪"
}
func main() {
var c Cat
fmt.Println("猫：",c.say())
var d Dog
fmt.Println("狗：",d.say())
}
结果：
猫： 喵喵喵
狗： 汪汪汪
Process finished with exit code 0上面的代码中定义了猫和狗，都会叫，你会发现main函数中有明显的代码重复，如果动物越多，那么say()函数会越多，那怎样优化呢？
可以使用接口！Go语言提倡面向接口编程。
每个接口由数个方法组成，接口的定义格式如下：
type 接口类型名 interface{
方法名1( 参数列表1 ) 返回值列表1
方法名2( 参数列表2 ) 返回值列表2
…
}
其中：
接口名：使用type将接口定义为自定义的类型名。
Go语言的接口在命名时，一般会在单词后面添加er,如有写操作的接口叫Writer,有字符串功能的接口叫Stringer等。
接口名最好要能突出该接口的类型含义。
方法名：当方法名首字母是大写且这个接口类型名首字母是大写时，这个方法可以被接口所在的包(package)之外的代码访问。
参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。
例如：
type writer interface{
Write([]byte) error
}
当看到这个接口类型的值时i，不知道它是什么，唯一知道的就是通过它的Writer方法来做一些事情。一个对象只要全部实现了接口中的方法，那么就实现了这个接口。即接口就是一个需要实现的方法列表。package main
import "fmt"
//定义一个Sayer接口
type Sayer interface {
say()
}
//定义dog和cat两个结构体
type dog struct {}
type cat struct {}
//因为Sayer接口中只有一个say方法，所以我们只需要给dog和cat分别实现say()方法，就能实现Sayer接口了。
func (d dog) say() {
fmt.Println("汪汪汪")
}
func (c cat) say() {
fmt.Println("喵喵喵")
}
//接口实现就是这样，只要实现了接口中的所有方法，就实现了这个接口。
func main() {
var d dog
var c cat
d.say()
c.say()
}
结果：
汪汪汪
喵喵喵
Process finished with exit code 0那么实现了接口有什么用呢？
接口类型变量能够存储所有实现了该接口的实例。
例如上面的示例中，Sayer类型的变量能够存储dog和cat类型的变量。package main
import "fmt"
//定义一个Sayer接口
type Sayer interface {
say()
}
//定义dog和cat两个结构体
type dog struct {}
type cat struct {}
//因为Sayer接口中只有一个say方法，所以我们只需要给dog和cat分别实现say()方法，就能实现Sayer接口了。
func (d dog) say() {
fmt.Println("汪汪汪")
}
func (c cat) say() {
fmt.Println("喵喵喵")
}
//接口实现就是这样，只要实现了接口中的所有方法，就实现了这个接口。
func main() {
var x Sayer //声明一个Sayer类型的变量x
c := cat{} //实例化一个cat
d := dog{} //实例化一个dog
x = c //可以吧cat示例直接赋值给x
x.say() //喵喵喵
x = d //可以吧dog实力直接赋值给x
x.say() //汪汪汪
}
结果：
喵喵喵
汪汪汪
Process finished with exit code 0使用值接收者实现接口和使用指针接收者实现接口有什么区别呢？看一下下面的例子package main
import "fmt"
type Mover interface {
move()
}
type dog struct {}
//值接收者实现接口
func (d dog) move() {
fmt.Println("狗会动！")
}
func main() {
var x Mover
var wangcai = dog{} //旺财是dog类型
x = wangcai //x可以接收dog类型
x.move()
var fugui = &dog{} //富贵是*dog类型
x = fugui //x可以接收*dog类型
x.move()
}
结果：
狗会动！
狗会动！
Process finished with exit code 0从上面的代码中我们可以发现，使用值接收者实现接口侯，不管是dog结构体还是结构体指针*dog类型的变量，都可以赋值给改接口变量。
因为Go语言中有对指针类型变量求值的语法糖，dog指针fugui内部会自动求值。package main
import "fmt"
type Mover interface {
move()
}
type dog struct {}
//值接收者实现接口
func (d *dog) move() {
fmt.Println("狗会动！")
}
func main() {
var x Mover
var wangcai = dog{} //旺财是dog类型
x = wangcai //x不可以接收dog类型，直接报错
x.move()
var fugui = &dog{} //富贵是*dog类型
x = fugui //x可以接收*dog类型
x.move()
}此时实现Mover接口的是*dog类型，所以不能给x传入dog类型的wangcai，此时x只能存储*dog类型的值。首先请观察下面的这段代码，然后请回答这段代码能不能通过编译？
type People interface {
Speak(string) string
}
type Student struct{}
func (stu *Student) Speak(think string) (talk string) {
if think == "sb" {
talk = "你是个大帅哥"
} else {
talk = "您好"
}
return
}
func main() {
var peo People = Student{} //不能通过编译，这里要变为var peo People = &Student{}
think := "思考"
fmt.Println(peo.Speak(think))
}一个类型可以同时实现多个接口，而接口间，彼此是独立的，不知道对方的实现。
例如，狗可以叫，也可以动。我们可以分别定义Sayer接口和Mover接口。package main
import "fmt"
type Mover interface {
move()
}
type Sayer interface {
say()
}
type dog struct {
name string
}
//实现Mover接口
func (d dog) move() {
fmt.Printf("%s狗会动！\n",d.name)
}
//实现Sayer接口
func (d dog) say() {
fmt.Printf("%s狗会叫！\n",d.name)
}
func main() {
var x Sayer
var y Mover
//dog既可以实现Sayer接口，也可以实现Mover接口
var a = dog{name:"旺财"}
x = a
y = a
x.say()
y.move()
}
结果：
旺财狗会叫！
旺财狗会动！
Process finished with exit code 0package main
import "fmt"
//Go语言中不同的类型可以实现同一个接口，首先定义一个Mover接口
type Mover interface {
move()
}
type dog struct {
name string
}
type car struct {
brand string
}
//dog实现Mover接口
func (d dog) move() {
fmt.Printf("%s狗会动！\n",d.name)
}
//car实现Mover接口
func (c car) move() {
fmt.Printf("%s小车会跑！\n",c.brand)
}
//这时候就可以在代码中把狗和汽车当成一个会动的物体来处理，不需要关注它们具体是什么，只需要调用它们的move方法就可以了。
func main() {
var x Mover
//dog既可以实现Sayer接口，也可以实现Mover接口
var a = dog{name:"旺财"}
var b = car{brand:"宝马"}
x = a
x.move()
x = b
x.move()
}
结果：
旺财狗会动！
宝马小车会跑！
Process finished with exit code 0一个接口的方法，不一定需要由一个类型完全实现，接口的方法可以通过在类型中嵌入其他类型或结构体来实现。
package main
import "fmt"
//洗衣机接口
type WashingMachine interface {
wash()
dry()
}
//甩干器
type dryer struct {}
//海尔洗衣机
type haier struct {
dryer //嵌入甩干器
}
//实现WashingMachine接口的dry()方法
func (d dryer) dry() {
fmt.Println("甩一甩")
}
//实现WashingMachine接口的wash()方法
func (h haier) wash() {
fmt.Println("wash")
}
func main() {
var d dryer
var h haier
d.dry()
h.wash()
h.dry()
}
结果：
甩一甩
wash
甩一甩
Process finished with exit code 0接口与接口之间可以通过嵌套创造出新的接口。package main
import "fmt"
//Sayer接口
type Sayer interface {
say()
}
//Mover接口
type Mover interface {
move()
}
//接口嵌套
type animal interface {
Sayer
Mover
}
//嵌套得到的接口的使用与普通接口一样，这里让cat实现animal接口：
type cat struct {
name string
}
func (c cat) say() {
fmt.Println("喵喵喵")
}
func (c cat) move() {
fmt.Println("猫会动")
}
func main() {
var x animal
x = cat{name:"花花"}
x.say()
x.move()
}
结果：
喵喵喵
猫会动
Process finished with exit code 0空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。
空接口类型的变量可以存储任意类型的变量。package main
import "fmt"
func main() {
var x interface{}
s := "hello vita"
x = s
fmt.Printf("type:%T value:%v\n",x,x)
i := 100
x = i
fmt.Printf("type:%T value:%v\n",x,x)
b := true
x = b
fmt.Printf("type:%T value:%v\n",x,x)
}
结果：
type:string value:hello vita
type:int value:100
type:bool value:true
Process finished with exit code 0使用空接口实现可以接收任意类型的函数参数。
package main
import "fmt"
func show(x interface{}) {
fmt.Printf("type:%T value:%v\n",x,x)
}
func main() {
show("hello vita")
show(100)
show(true)
}
结果：
type:string value:hello vita
type:int value:100
type:bool value:true
Process finished with exit code 0使用空接口，可以实现map的value是任意值。
package main
import "fmt"
func main() {
var studentInfo = make(map[string]interface{})
studentInfo["name"] = "vita"
studentInfo["age"] = 18
studentInfo["married"] = true
fmt.Println(studentInfo)
}
结果：
map[age:18 married:true name:vita]
Process finished with exit code 0空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？
接口值：
一个接口的值（简称接口值）是由一个"具体类型"和"具体类型的值"两部分组成，这两部分分别称为接口的"动态类型"和"动态值"。
看下面的例子：
var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil
想要判断空接口中的值，这时候可以使用类型断言，语法格式为：
x.(T)其中： x：表示类型为interface{}的变量 T：表示断言x可能是的类型 该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false表示断言失败。
package main
import "fmt"
func main() {
var x interface{}
x = "hello vita"
v,ok := x.(string)
if ok{
fmt.Println(v)
}else{
fmt.Println("类型不是string")
}
}
结果：
hello vita
Process finished with exit code 0上面的实例中，如果要断言多次就要写多个if判断，这个时候我们可以使用switch语句来实现：
package main
import "fmt"
func main() {
var x interface{}
x= "hello"
switch v := x.(type) {
case string:
fmt.Printf("x是string类型，value is %v\n",v)
case int:
fmt.Printf("x是int类型，value is %v\n",v)
case bool:
fmt.Printf("x是bool类型，value is %v\n",v)
}
}
结果：
x是string类型，value is hello
Process finished with exit code 0以上就是Golang接口的详细内容了，看完之后是否有所收获呢？如果想了解更多相关内容，欢迎关注创新互联行业资讯！
另外有需要云服务器可以了解下创新互联cdcxhl.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
