Golang接口(interface)的使用指南

Golang接口(interface)的使用指南 接口类型是多态、类型断言、抽象和嵌入的关键

func main() {
    fmt.Println("hello world")
}
1 回复

更多关于Golang接口(interface)的使用指南的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中，接口（interface）是实现多态、类型断言和抽象的核心机制。下面通过具体示例说明接口的基本用法和关键特性。

1. 接口定义与实现

接口定义了一组方法签名，任何类型只要实现了这些方法，就隐式满足了该接口。

package main

import "fmt"

// 定义接口
type Speaker interface {
    Speak() string
}

// 定义结构体
type Dog struct {
    Name string
}

type Cat struct {
    Name string
}

// Dog 实现 Speaker 接口
func (d Dog) Speak() string {
    return fmt.Sprintf("%s says: Woof!", d.Name)
}

// Cat 实现 Speaker 接口
func (c Cat) Speak() string {
    return fmt.Sprintf("%s says: Meow!", c.Name)
}

func main() {
    // 多态：通过接口类型处理不同对象
    animals := []Speaker{
        Dog{Name: "Buddy"},
        Cat{Name: "Whiskers"},
    }

    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }
}

输出：

Buddy says: Woof!
Whiskers says: Meow!

2. 类型断言

类型断言用于在运行时检查接口值的具体类型。

func describe(s Speaker) {
    // 类型断言
    if dog, ok := s.(Dog); ok {
        fmt.Printf("It's a dog: %s\n", dog.Name)
    } else if cat, ok := s.(Cat); ok {
        fmt.Printf("It's a cat: %s\n", cat.Name)
    } else {
        fmt.Println("Unknown animal type")
    }
}

func main() {
    animals := []Speaker{
        Dog{Name: "Buddy"},
        Cat{Name: "Whiskers"},
    }

    for _, animal := range animals {
        describe(animal)
    }
}

输出：

It's a dog: Buddy
It's a cat: Whiskers

3. 接口嵌入（组合）

接口可以通过嵌入其他接口来组合功能。

// 基础接口
type Mover interface {
    Move() string
}

// 组合接口
type Animal interface {
    Speaker
    Mover
}

// Bird 实现组合接口
type Bird struct {
    Name string
}

func (b Bird) Speak() string {
    return fmt.Sprintf("%s says: Tweet!", b.Name)
}

func (b Bird) Move() string {
    return fmt.Sprintf("%s is flying", b.Name)
}

func main() {
    bird := Bird{Name: "Robin"}
    
    var animal Animal = bird
    fmt.Println(animal.Speak())
    fmt.Println(animal.Move())
}

输出：

Robin says: Tweet!
Robin is flying

4. 空接口

空接口 interface{} 可以保存任何类型的值，常用于需要处理未知类型的情况。

func printValue(v interface{}) {
    fmt.Printf("Value: %v, Type: %T\n", v, v)
}

func main() {
    printValue(42)
    printValue("hello")
    printValue(Dog{Name: "Rex"})
}

输出：

Value: 42, Type: int
Value: hello, Type: string
Value: {Rex}, Type: main.Dog

这些示例展示了Go语言接口的核心用法，包括多态、类型断言、抽象和接口嵌入。接口是Go语言类型系统的关键组成部分，能够编写出灵活且可扩展的代码。

回到顶部