Go语言方法实现接口

接口

在Go语言中，接口不需要显式声明。只需要通过方法实现接口的功能并指向自定义类型（结构体或其他自定义类型变量）。 Go 不关心具体实现的接口，只关心实现该接口的函数。

当实现接口的功能时，方法指向的数据结构自动实现同名函数的接口，因此可以实现多重继承，降低耦合。

接口是带有方法的接口。所有接口都没有方法体。该接口不需要显式实现。只要实现了接口的方法，就是接口的实现类型。

package main

import (
	"fmt"
)

func main() {
    
	phone1 := Phone{
    }
	phone1.start()
	phone1.stop()

	camera1 := Camera{
    }
	camera1.start()
	camera1.stop()

}

//定义接口
type USB interface {
    
	start()
	stop()
}

// 手机结构体
type Phone struct {
    
}

// 方法将结构体与函数联系起来
func (p Phone) start() {
    
	fmt.Println("phone usb is working")
}

func (p Phone) stop() {
    
	fmt.Println("phone usb is stopping")
}

// 摄像机结构体
type Camera struct {
    
}

func (c Camera) stop() {
    
	fmt.Println("camera usb is stopping")
}

func (c Camera) start() {
    
	fmt.Println("camera usb is working")
}

接口默认为指针类型，如果不初始化则默认为nil。空接口没有任何方法，因此所有类型都实现空接口。

一个类型需要实现了接口，才能将实例赋给接口类型变量，主要是自定义（通过type关键字）的类型，都可以实现接口，不仅仅是结构体。一个自定义的类型可以实现多个接口，接口也可以继承别的接口，通过及接口内嵌完成，必须将接口的所有方法都实现。

由于Go继承的独特性，没有class,implements等关键字的显示声明，仅仅和函数强关联，依次在Go实现多继承时，变量的类型仍然唯一。如下：

class A{
    

}

class B{
    
}

class C extends A,B{
    

}

如果在Java中多继承，就会出现类的成员变量和方法均不一样的状况，
如果实现多继承，那么子类就是两个父类的并集，子类有了其本该具有的特性和行为。这显然不太合理。

type A interface{
    
	method1()
	method2()
	...
}

type B interface{
    
	function1()
	function2()
	...
}

type C struct {
    
}

func (c C) method1(){
    
}

func (c C) function1(){
    
}

在Go中多继承，每个结构体有自己独特的属性，另外话可以选择性的继承接口的方法，
使结构体具有自己独特的行为

在Go语言中，只有实现了接口的所有方法，自定义类型才可以说实现了接口。在接口实现过程中，自定义类型和接口的方法可能会交叉，也可能直接实现接口的所有方法。

package main

import "fmt"

//父母接口
type Parent interface {
    
	ShowParent()
}

//亲戚接口
type Relative interface {
    
	ShowRalative()
}

//儿子结构体
type Son struct {
    
	name string
}

func (son Son) ShowSon() {
    
	fmt.Println("my name is mike")
}

func (son Son) ShowParent() {
    
	fmt.Println("my parent ...")
}

func (son Son) ShowRalative() {
    
	fmt.Println("my relative...")
}

func main() {
    
	var son Son
	son.name = "xiaoxu"
	son.ShowParent()
	son.ShowRalative()
	son.ShowSon() 

}

自定义类型可以实现多个接口并与接口方法相交。

type myType int

func (mype myType) ShowRalative() {
    
	fmt.Println("float is my relative")
}

func (mype myType) ShowParent() {
    
	fmt.Println("integer is my ShowParent")
}

接口继承

Go接口之间也可以发生继承，继承后的接口拥有父类的所有方法。

type A interface {
    
	Aint()
}

type B interface {
    
	Bint()
}

type C interface {
    
	A
	B
}

以前结构体和接口是不能继承的。一个代表元素的集合，另一个代表方法的集合。

type A interface {
    
	Aint()
}

type ATest struct {
    
	A
}

接口是一种类型，所以在接口体中也可以这样写。但由于接口方法没有方法体，所以必须继承并重写。因此无法实例化接口，所以上面的写法不会报语法错误，但语义错误。的。编译失败。