Go接口

package main

import "fmt"

func main() {
	/*
	接口：interface
		1. 在Go中，接口是一组方法签名。当类型为接口中的所有方法提供定义时，它被称为实现接口。它与OOP非常相似。
		接口指定了类型应该具有的方法，类型决定了如何实现这些方法。

 		2. 它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

  		3. 接口定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了该接口。

		Go语言中，接口和实现类的关系，是非侵入式
			//其他语言中，要显示的定义
			class Mouse implements USB{}

	1.当需要接口类型的对象时，可以使用任意实现类对象代替
	2.接口对象不能访问实现类中的属性，赋值给一个变量（实例对象）是可以访问的


	多态：一个事物的多种形态
		go语言通过接口模拟多态

		就一个接口的实现
			1.看成实现本身的类型，能够访问实现类中的属性和方法
			2.看成是对应的接口类型，那就只能够访问接口中的方法（其他语言中就是只能访问父类的方法）

	接口的用法：
		1.一个函数如果接受接口类型作为参数，那么实际上可以传入该接口的任意实现类型对象作为参数。
		2.定义一个类型为接口类型，实际上可以赋值为任意实现类的对象


	鸭子类型：针对动态类型语言来说的（Python），长得像鸭子，走起路来像鸭子，叫起来像鸭子，那么它就是鸭子
		1. 是一种类型推断策略
		2. 关注的是对象如何被使用，而不是对象本身的类型
		3. Go不要求显示显示声明实现了那个接口，接口的实现只要实现了方法就可以，Go也支持鸭子模型

	 */
	//1.创建Mouse类型
	m1 := Mouse{"罗技小红"}
	fmt.Println(m1.name)
	//2.创建FlashDisk
	f1 := FlashDisk{"闪迪64G"}
	fmt.Println(f1.name)

	testInterface(m1) //参数是USB接口类型对象
	testInterface(f1)

	var usb USB
	usb= f1
	usb.start()
	usb.end()
	//fmt.Println(usb.name)

	f1.deleteData()
	//usb.de

	var arr [3]USB
	arr[0] = m1
	arr[1] = f1
	fmt.Println(arr)
}

//1.定义接口
type USB interface {
	start() //USB设备开始工作
	end() //USB设备结束工作
}

//2.实现类
type Mouse struct {
	name string
}
type FlashDisk struct {
	name string
}

func (m Mouse)start(){
	fmt.Println(m.name,"鼠标，准备就绪，可以开始工作了，点点点。。")
}
func (m Mouse) end(){
	fmt.Println(m.name,"结束工作，可以安全退出。。")
}

func (f FlashDisk)start(){
	fmt.Println(f.name,"准备开始工作，可以进行数据的存储。。")
}
func (f FlashDisk)end(){
	fmt.Println(f.name,"可以弹出。。")
}
func (f FlashDisk) deleteData(){
	fmt.Println(f.name,"U盘删除数据。。")
}

//3.测试方法
func testInterface(usb USB){ //usb = m1  usb = f1
	usb.start()
	usb.end()
}

package main

import "fmt"

func main() {
	/*
	空接口(interface{})
		不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值。

	fmt包下的Print系列函数的参数就有空接口：
		//接收可变参数，任意类型
		func Print(a ...interface{}) (n int, err error)
		func Printf(format string, a ...interface{}) (n int, err error)
		func Println(a ...interface{}) (n int, err error)
	 */
	var a1 A = Cat{"花猫"}
	var a2 A = Person{"王二狗",30}
	var a3 A = "haha"
	var a4 A = 100
	fmt.Println(a1)
	fmt.Println(a2)
	fmt.Println(a3)
	fmt.Println(a4)
	test1(a1)
	test1(a2)
	test1(3.14)
	test1("Ruby")

	test2(a3)
	test2(1000)

	//map，key字符串，value任意类型
	map1 := make(map[string]interface{})
	map1["name"] = "李小花"
	map1["age"] = 30
	map1["friend"] = Person{"Jerry",18}
	fmt.Println(map1)

	//切片，存储任意类型的数据
	slice1 := make([]interface{},0,10)
	slice1 = append(slice1,a1,a2,a3,a4,100,"abc")
	fmt.Println(slice1)

	test3(slice1)

}

func test3(slice2 []interface{}){
	for i:=0;i<len(slice2);i++{
		fmt.Printf("第%d个数据：%v\n",i+1,slice2[i])
	}
}

//接口A是空接口，理解为代表了任意类型
func test1(a A){ //这个空接口是有名字的
	fmt.Println(a)
}

func test2(a interface{}){
	fmt.Println("--->",a)
}

//空接口
type A interface {

}
type Cat struct {
	color string
}
type Person struct {
	name string
	age int
}