Golang学习之接口的使用
摘要
Golang的接口在实际的开发当中具有重要的作用，掌握接口的使用可以在一定场景下实现一些特殊的功能。
正文
本文主要围绕以下几个方面来讲解Golang接口的使用。
什么是接口
在Golang中，接口是包含一类方法的数据结构，定义为
type name interface{
method1(param_list) return_type
method2(param_list) return_type
....
methodn(param_list) return_type
}
接口的作用是抽象化这些方法，即metho1,method2, ⋯ \cdots ⋯,methodn是没有实体的函数名。这些方法具体的行为由具体结构体或变量确定。
- 举例说明
package main
import (
"fmt"
"reflect"
)
type A struct{
}
func(a *A)handle(x,y int){
fmt.Println(reflect.TypeOf(a),x+y)
}
type B struct{
}
func(b *B)handle(x,y int){
fmt.Println(reflect.TypeOf(b),x*y)
}
type Face interface{
handle(x,y int)
}
func main() {
fmt.Println("******Type A*****")
var a *A
var c Face
c=a;
c.handle(1,2);
fmt.Println("******Type B*****")
var b *B
c=b;
c.handle(1,2)
}
执行结果如下
除了上述功能外，接口的另一个功能是向用户暴露接口中定义过的方法，而隐藏没有定义过的方法。
例如，在下面代码中，类型 A定义了两个方法，分别是handle和handle1，而接口类型Face仅仅抽象出了一个方法handle。那么，将结构体指针变量a赋值给c以后，通过变量c智能看到handle方法。具体测试代码如下：
package main
import (
"fmt"
"reflect"
)
type A struct{
}
func (a *A)handle(x,y int){
fmt.Println(reflect.TypeOf(a),x+y)
}
func (a *A)handle1(){
fmt.Println("Hello World!")
}
type Face interface{
handle(x,y int)
}
func main() {
fmt.Println("******Type A*****")
var a *A
var c Face
c=a;
c.handle(1,3)
}
具体情况如下
- 接口使用的注意事项
接口具体是接收指针变量还是普通变量，由结构体定义方法的方式确定
-- 结构体定义方法形式如下，则传递指针变量
func (a *A) method(paralist) return_type{
.....
return return_type
}
-- 结构体定义方法形式如下，则传递普通变量
func (a A) method(paralist) return_type{
.....
return return_type
}
接口中的方法全包含在接口体定义的方法中
接口作为函数的形参
- 输入参数
作为函数的输入参数，用于选择满足条件的实参。
package main
import (
"fmt"
"reflect"
)
type A struct{
}
func (a *A)handle(x,y int){
fmt.Println(reflect.TypeOf(a),x+y)
}
func (a *A)handle1(){
fmt.Println("Type:A")
}
type B struct{
}
func (b *B)handle(x,y int){
fmt.Println(reflect.TypeOf(b),x*y)
}
func (b *B)handle1(){
fmt.Println("Type:B")
}
type Face interface{
handle(x,y int)
}
func main() {
fmt.Println("******Type A*****")
var a *A
var c Face
c=a;
process(a)
fmt.Println("******Type B*****")
var b *B
c=b;
process(c)
}
func process(f Face) {
// check the type of inputing argument
switch t:=f.(type){
case *A:
t.handle1()
case *B :
t.handle1()
}
}
上述实例的执行结果如下：
- 输出参数
限定输出满足指定接口的结果，具体如下
package main
import (
"fmt"
"reflect"
)
type A struct{
X int
}
func (a *A)handle(x,y int){
fmt.Println(reflect.TypeOf(a),x+y)
}
func (a *A)handle1(){
fmt.Println("Type:A")
}
type Face interface{
handle(x,y int)
}
func main() {
var a A
a.X=4
b:=process(&a)
c:=b.(*A)
fmt.Printf("addr a=%p,addr b=%p, addr c=%p\n",&a,b,c)
fmt.Println(c.X)
}
func process(f *A) Face{
return f
}
实例执行结果为：
用结构体和接口实现类和类的继承
Golang没有像C++一样的类，在Golang中，继承的实现是依靠结构体来实现，为了限定子类只继承部分父类的方法，这里需要引入接口来实现。
- 基本结构体
type A struct {
varI Type1
varII Type2
}
func(a *A) Method(paramlist) return_type{
.....
return return_type
}
- 继承父类结构体指定方法
package main
import (
"fmt"
"reflect"
)
type A struct{
X int
}
func (a *A)handle(x,y int){
fmt.Println(reflect.TypeOf(a),x+y)
}
func (a *A)handle1(){
fmt.Println("Type:A")
}
type Face interface{
handle(x,y int)
}
type B struct{
z Face
}
func main() {
b:=Init()
b.z.handle(1,2)
}
func Init() *B{
a:=new(A)
return &B{a}
}
此时，结构体B中将包含架构体A唯一的方法handle.
总结
Golang中，接口是非常关键的数据类型，只有掌握并使用号接口，才能更好地利用Golang进行相关的项目开发及研发工作。