Go 语言接口 20

在 Go 语言中，接口（Interface）是一种抽象的概念，它定义了一个对象所需的方法和属性。接口可以用来定义一个对象的行为，而不关心对象的具体实现。

定义接口

在 Go 语言中，接口可以使用 interface 关键字来定义。例如：

type Printer interface {
    Print()
}

上面的代码定义了一个名为 Printer 的接口，它包含一个名为 Print 的方法。

实现接口

在 Go 语言中，一个结构体可以实现一个接口，通过实现该接口中的所有方法。例如：

type MyPrinter struct{}

func (p *MyPrinter) Print() {
    fmt.Println("Hello, World!")
}

func main() {
    p := &MyPrinter{}
    p.Print() // Output: Hello, World!
}

上面的代码定义了一个名为 MyPrinter 的结构体，它实现了 Printer 接口中的 Print 方法。

接口的使用

在 Go 语言中，接口可以用来定义一个对象的行为，而不关心对象的具体实现。例如：

func printSomething(p Printer) {
    p.Print()
}

func main() {
    p := &MyPrinter{}
    printSomething(p) // Output: Hello, World!
}

上面的代码定义了一个名为 printSomething 的函数，它接受一个 Printer 接口的对象作为参数，然后调用该对象的 Print 方法。

接口的组合

在 Go 语言中，接口可以组合多个其他接口。例如：

type Writer interface {
    Write([]byte) (int, error)
}

type Reader interface {
    Read([]byte) (int, error)
}

type WriterReader interface {
    Writer
    Reader
}

func main() {
    w := &Writer{}
    r := &Reader{}
    wr := &WriterReader{}
    w.Write([]byte("Hello")) // Output: 5
    r.Read([]byte("Hello")) // Output: 5
    wr.Write([]byte("Hello")) // Output: 5
    wr.Read([]byte("Hello")) // Output: 5
}

上面的代码定义了三个接口：Writer、Reader 和 WriterReader。WriterReader 接口继承了 Writer 和 Reader 接口的方法。

接口的继承

在 Go 语言中，接口可以继承其他接口。例如：

type Animal interface {
    Eat()
}

type Dog struct{}

func (d *Dog) Eat() {
    fmt.Println("Dog eats")
}

type Cat struct{}

func (c *Cat) Eat() {
    fmt.Println("Cat eats")
}

type Pet interface {
    Animal
    Play()
}

func (d *Dog) Play() {
    fmt.Println("Dog plays")
}

func (c *Cat) Play() {
    fmt.Println("Cat plays")
}

func main() {
    d := &Dog{}
    c := &Cat{}
    p := &Pet{}
    d.Eat() // Output: Dog eats
    c.Eat() // Output: Cat eats
    d.Play() // Output: Dog plays
    c.Play() // Output: Cat plays
}

上面的代码定义了三个接口：Animal、Pet 和 Dog 和 Cat。Pet 接口继承了 Animal 接口的方法，并添加了一个名为 Play 的方法。

接口的实现

在 Go 语言中，一个结构体可以实现一个接口，通过实现该接口中的所有方法。例如：

type MyPet struct{}

func (p *MyPet) Eat() {
    fmt.Println("My pet eats")
}

func (p *MyPet) Play() {
    fmt.Println("My pet plays")
}

func main() {
    p := &MyPet{}
    p.Eat() // Output: My pet eats
    p.Play() // Output: My pet plays
}