Go笔记(十二)：接口

1、接口的声明

　　Go语言中的接口是一种新的类型定义，拥有将具有共性的方法定义在一起的特性。任何其他类型只要实现了这些方法就是实现了这个接口。

语法详情如下：

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

　　示例代码如下：

package main

import "fmt"

// 不同结构体的接受者
type Plane struct {
   name string
}

// 要实现某个接口，必须实现该接口的所有方法
type Bird struct {
   name string
   color string
}

// 定义接口
type Flying interface {
   // 定义接口方法
   takeoff()
   descend()
}

// 方法的接收者是 Bird
func (bd Bird) takeoff() {
   fmt.Printf("bd.name: %v, bd.color: %v  take off \n", bd.name, bd.color)
}
func (bd Bird) descend() {
   fmt.Printf("bd.name: %v, bd.color: %v  descend \n", bd.name, bd.color)
}

// 方法的接收者是 Plane
func (pe Plane) takeoff() {
   fmt.Printf("pe.name: %v takeoff \n", pe.name)
}
func (pe Plane) descend() {
   fmt.Printf("pe.name: %v descend \n", pe.name)
}

func main() {
   bd := Bird{"猫头鹰", "黑色"}
   bd.takeoff()
   bd.descend()
   fmt.Printf("--------------\n")
   pe := Plane{"爱国者"}
   pe.takeoff()
   pe.descend()
}

2、接口接受者类型

2.1、值类型

package main

import "fmt"

// 定义接口
type Animal interface {
   eat(name string)
}
// 声明结构体
type Cat struct {
   name string
}
// 值类型接受者
func (cat Cat) eat(name string) {
   cat.name = cat.name + "-v"
   fmt.Printf("cat.name: %v eating \n", cat.name)
}

// 接口值类型接受者
func main() {
   cat01 := Cat{
      name: "pter",
    }
   fmt.Printf("cat01: %v\n", cat01)
   cat01.eat(cat01.name)
   fmt.Printf("cat01: %v\n", cat01)
}

2.2、指针类型

package main

import "fmt"

// 定义接口
type Animal interface {
   sleep(name string)
}
// 声明结构体
type Cat struct {
   name string
}

// 指针类型接受者
func (cat *Cat) sleep(name string) {
   cat.name = cat.name + "-p"
   fmt.Printf("cat.name: %v sleep \n", cat.name)
}

// 接口指针类型接受者
func main() {
   cat := Cat{
      name: "pter",
    }
   fmt.Printf("cat: %v\n", cat)
   cat.sleep(cat.name)
   fmt.Printf("cat: %v\n", cat)
}

3、接口与类型的关系

3.1、一个类型实现多个接口

package main

import "fmt"

// 有声音的接口
type Audible interface {
   playMusic()
}
// 可观看的接口
type Viewable interface {
   viewMovie()
}
// 结构体
type Computer struct{}
// 接收者为 Computer 的方法
func (c Computer) playMusic() {
   fmt.Println("play music...")
}
func (c Computer) viewMovie() {
   fmt.Println("view movie...")
}

// 一个类型实现多个接口
func main() {
   computer := Computer{}
   computer.playMusic()
   computer.viewMovie()
}

3.2、多个类型实现同一接口

package main

import "fmt"

type BC struct {
   kind string
}
type BM struct {
   kind string
}
type Car interface {
   run()
}
func (m BM) run() {
   fmt.Println(" 宝马在高速行驶 ")
}
func (c BC) run() {
   fmt.Println(" 奔驰在高速行驶 ")
}

func main() {
   m := BM{}
   c := BC{}
   m.run()
   c.run()
}

3.3、接口嵌套

package main

import "fmt"

// 爬行的
type Crawling interface {
   crawl()
}
// 游泳的
type Natatorial interface {
   swim()
}
// 接口组合
type AmphibiousAnimals interface {
   Crawling
   Natatorial
}
// 定义结构体
type tortoise struct{}
// 实现接口方法
func (t tortoise) crawl() {
   fmt.Println(" tortoise crawl ")
}
// 实现接口方法
func (t tortoise) swim() {
   fmt.Println(" tortoise swim ")
}

func main() {
   t := tortoise{}
   t.crawl()
   t.swim()
}

4、模拟接口设计原则

　　面向对象的OCP设计原则，是可复用设计的基石，"开闭"原则(Open-Closed Principle)，对拓展是开放的，对修改是关闭的。

　　Go语言虽不是面向对象的语言，但可以模拟实现此原则。

package main

import "fmt"

// ocp设计原则
type Pet interface {
   eat()
}
type Dog struct{}
func (dog Dog) eat() {
   fmt.Println(" dog eat")
}

type Person struct{}
// 利用多态，设计java中的向上类型转换
func (per Person) care(p Pet) {
   p.eat()
}
// 新增一个宠物，无需修改原有代码，只需做拓展即可
type Pig struct{}
func (pig Pig) eat() {
   fmt.Println(" pig eat")
}
func main() {
   dog := Dog{}
   per := Person{}
   per.care(dog)

   pig := Pig{}
   per.care(pig)
}