Go 语言接口 - GO教程

首页 / 教程 / Go 语言教程 / Go 语言接口 - GO教程

Go 语言接口

接口（interface）是 Go 语言中的一种类型，用于定义行为的集合，它通过描述类型必须实现的方法，规定了类型的行为契约。

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

Go 的接口设计简单却功能强大，是实现多态和解耦的重要工具。

接口可以让我们将不同的类型绑定到一组公共的方法上，从而实现多态和灵活的设计。

接口的特点

隐式实现 ：

  • Go 中没有关键字显式声明某个类型实现了某个接口。
  • 只要一个类型实现了接口要求的所有方法，该类型就自动被认为实现了该接口。

接口类型变量 ：

  • 接口变量可以存储实现该接口的任意值。
  • 接口变量实际上包含了两个部分：
    • 动态类型 ：存储实际的值类型。
    • 动态值 ：存储具体的值。

零值接口 ：

  • 接口的零值是 nil 。
  • 一个未初始化的接口变量其值为 nil ，且不包含任何动态类型或值。

空接口 ：

  • 定义为 interface{} ，可以表示任何类型。

接口的常见用法

  1. 多态 ：不同类型实现同一接口，实现多态行为。
  2. 解耦 ：通过接口定义依赖关系，降低模块之间的耦合。
  3. 泛化 ：使用空接口 interface{} 表示任意类型。

接口定义和实现

接口定义使用关键字 interface ，其中包含方法声明。

示例代码 
/* 定义接口 */typeinterface_nameinterface{method_name1[return_type]method_name2[return_type]method_name3[return_type]...method_namen[return_type]}/* 定义结构体 */typestruct_namestruct{/* variables */}/* 实现接口方法 */func(struct_name_variable struct_name)method_name1()[return_type]{/* 方法实现 */}...func(struct_name_variable struct_name)method_namen()[return_type]{/* 方法实现*/}

定义一个简单接口: 

type Shape interface {

    Area() float64

    Perimeter() float64

}
  • Shape 是一个接口，定义了两个方法： Area 和 Perimeter 。
  • 任意类型只要实现了这两个方法，就被认为实现了 Shape 接口。

实现接口: 类型通过实现接口要求的所有方法来实现接口。

示例代码 
packagemainimport("fmt""math")// 定义接口typeShapeinterface{Area()float64Perimeter()float64}// 定义一个结构体typeCirclestruct{Radiusfloat64}// Circle 实现 Shape 接口func(c Circle)Area()float64{returnmath.Pi*c.Radius*c.Radius}func(c Circle)Perimeter()float64{return2*math.Pi*c.Radius}funcmain(){c:=Circle{Radius:5}vars Shape=c// 接口变量可以存储实现了接口的类型fmt.Println("Area:",s.Area())fmt.Println("Perimeter:",s.Perimeter())}

执行以上代码，输出结果为： 

Area: 78.53981633974483

Perimeter: 31.41592653589793

空接口

空接口 interface{} 是 Go 的特殊接口，表示所有类型的超集。

  • 任意类型都实现了空接口。
  • 常用于需要存储任意类型数据的场景，如泛型容器、通用参数等。
示例代码 
packagemainimport"fmt"funcprintValue(valinterface{}){fmt.Printf("Value: %v, Type: %T\n",val,val)}funcmain(){printValue(42)// intprintValue("hello")// stringprintValue(3.14)// float64printValue([]int{1,2})// slice}

执行以上代码，输出结果为： 

Value: 42, Type: int

Value: hello, Type: string

Value: 3.14, Type: float64

Value: [1 2], Type: []int

类型断言

类型断言用于从接口类型中提取其底层值。

基本语法: 


value := iface.(Type)
  • iface 是接口变量。
  • Type 是要断言的具体类型。
  • 如果类型不匹配，会触发 panic 。
示例代码 
packagemainimport"fmt"funcmain(){variinterface{}="hello"str:=i.(string)// 类型断言fmt.Println(str)// 输出：hello}

带检查的类型断言

为了避免 panic，可以使用带检查的类型断言： 


value, ok := iface.(Type)
  • ok 是一个布尔值，表示断言是否成功。
  • 如果断言失败， value 为零值， ok 为 false 。
示例代码 
packagemainimport"fmt"funcmain(){variinterface{}=42ifstr,ok:=i.(string);ok{fmt.Println("String:",str)}else{fmt.Println("Not a string")}}

执行以上代码，输出结果为： 

Not a string

类型选择（type switch）

type switch 是 Go 中的语法结构，用于根据接口变量的具体类型执行不同的逻辑。

示例代码 
packagemainimport"fmt"funcprintType(valinterface{}){switchv:=val.(type){caseint:fmt.Println("Integer:",v)casestring:fmt.Println("String:",v)casefloat64:fmt.Println("Float:",v)default:fmt.Println("Unknown type")}}funcmain(){printType(42)printType("hello")printType(3.14)printType([]int{1,2,3})}

执行以上代码，输出结果为： 

Integer: 42

String: hello

Float: 3.14

Unknown type

接口组合

接口可以通过嵌套组合，实现更复杂的行为描述。

示例代码 
packagemainimport"fmt"typeReaderinterface{Read()string}typeWriterinterface{Write(datastring)}typeReadWriterinterface{ReaderWriter}typeFilestruct{}func(f File)Read()string{return"Reading data"}func(f File)Write(datastring){fmt.Println("Writing data:",data)}funcmain(){varrw ReadWriter=File{}fmt.Println(rw.Read())rw.Write("Hello, Go!")}

动态值和动态类型

接口变量实际上包含了两部分：

  1. 动态类型 ：接口变量存储的具体类型。
  2. 动态值 ：具体类型的值。

动态值和动态类型示例：

示例代码 
packagemainimport"fmt"funcmain(){variinterface{}=42fmt.Printf("Dynamic type: %T, Dynamic value: %v\n",i,i)}

执行以上代码，输出结果为： 


Dynamic type: int, Dynamic value: 42

接口的零值

接口的零值是 nil。

当接口变量的动态类型和动态值都为 nil 时，接口变量为 nil。

接口零值示例：

示例代码 
packagemainimport"fmt"funcmain(){variinterface{}fmt.Println(i==nil)// 输出：true}

练习实例

以下两个实例演示了接口的使用：

示例代码 
packagemainimport("fmt")typePhoneinterface{call()}typeNokiaPhonestruct{}func(nokiaPhone NokiaPhone)call(){fmt.Println("I am Nokia, I can call you!")}typeIPhonestruct{}func(iPhone IPhone)call(){fmt.Println("I am iPhone, I can call you!")}funcmain(){varphone Phonephone=new(NokiaPhone)phone.call()phone=new(IPhone)phone.call()}

在上面的例子中，我们定义了一个接口 Phone ，接口里面有一个方法 call() 。然后我们在 main 函数里面定义了一个 Phone 类型变量，并分别为之赋值为 NokiaPhone 和 IPhone 。然后调用 call() 方法，输出结果如下： 


I am Nokia, I can call you!

I am iPhone, I can call you!

第二个接口实例：

示例代码 
packagemainimport"fmt"typeShapeinterface{area()float64}typeRectanglestruct{widthfloat64heightfloat64}func(r Rectangle)area()float64{returnr.width*r.height}typeCirclestruct{radiusfloat64}func(c Circle)area()float64{return3.14*c.radius*c.radius}funcmain(){vars Shapes=Rectangle{width:10,height:5}fmt.Printf("矩形面积: %f\n",s.area())s=Circle{radius:3}fmt.Printf("圆形面积: %f\n",s.area())}

以上实例中，我们定义了一个 Shape 接口，它定义了一个方法 area()，该方法返回一个 float64 类型的面积值。然后，我们定义了两个结构体 Rectangle 和 Circle，它们分别实现了 Shape 接口的 area() 方法。在 main() 函数中，我们首先定义了一个 Shape 类型的变量 s，然后分别将 Rectangle 和 Circle 类型的实例赋值给它，并通过 area() 方法计算它们的面积并打印出来，输出结果如下： 

矩形面积: 50.000000

圆形面积: 28.260000

需要注意的是，接口类型变量可以存储任何实现了该接口的类型的值。在示例中，我们将 Rectangle 和 Circle 类型的实例都赋值给了 Shape 类型的变量 s，并通过 area() 方法调用它们的面积计算方法。