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
}

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