Go语言之接口

面向对象编程思想—抽象
抽象是一种方法，一种研究把一类事物共有的属性和方法提取出来，形成一个物理模型的方法。

一、继承

1.代码的复用性提高了，减少代码冗余,易于扩展和维护
2.嵌套的结构体中所有字段和方法，不管首字母是大写还是小写都可以使用

package main

import "fmt"

type Student struct {
	Name  string
	age   int
	score float64
}

type Pupil struct {
	Student //嵌入Student结构体,类似于extend
}

type Gradute struct {
	Name string
	Student
	a Student //嵌套有名结构体，访问有名结构体字段时，结构体名必须带上
}

func (s *Student) ShowInfo() {
	fmt.Printf("name=%v,age=%v,score=%v\n", s.Name, s.age, s.score)
}

func (s *Student) SetScore(score float64) {
	s.score = score
}

func (p Pupil) testing() {
	fmt.Println("小学生正在考试...")
}

func (g Gradute) testing() {
	fmt.Println("大学生正在考试...")
}
func main() {
	p := &Pupil{}
	//创建结构体变量实例时，可以直接给各个匿名结构体字段赋值
	p1 := Pupil{
		Student{Name: "TOM", age: 10, score: 99},
	}
	fmt.Println(p1)
	p.Student.Name = "tom"
	p.Name = "smith" //匿名结构体字段方法访问可以简化，编译器自动寻找
	p.Student.age = 8
	p.testing()
	p.Student.SetScore(88)
	p.Student.ShowInfo()

	g := &Gradute{}
	//与结构体出现相同的字段和方法，采用就近原则访问
	//如果嵌入的两个结构体，有相同的字段和方法，必须指定匿名结构体名访问
	g.Name = "jack"
	g.ShowInfo() //student中的Name为空
}

二、接口

1.接口中可以定义一组方法，但不能实现，也不能包含任何变量，接口体现了多态和高内聚低耦合思想
2.Golang中的接口不需要显示实现，只要一个变量含有接口类中所有的方法，那么这个变量就实现了这个接口
3.只要是自定义类型，不仅仅是结构体类型，都可以实现接口
4.接口默认是一个指针，是引用类型，未初始化接口输出nil
5.所有类型都实现了空接口，即我们可以把任何一个变量赋值给空接口

1.接口快速入门

package main

import "fmt"

type Usb interface {
	start()
	stop()
}
type Phone struct {
}

func (p Phone) start() {
	fmt.Println("手机开始工作")
}

func (p Phone) stop() {
	fmt.Println("手机停止工作")
}

type Camera struct {
}

func (c Camera) start() {
	fmt.Println("相机开始工作")
}

func (c Camera) stop() {
	fmt.Println("相机停止工作")
}

type integer int

func (i integer) start() {
	fmt.Println("非结构体类型实现接口")
}
func (i integer) stop() {
	fmt.Println("非结构体类型实现接口了")
}

type Computer struct {
}

//只要是实现了Usb接口，就是指实现了接口中所有的方法
//只有实现了接口，才能将该变量赋给接口类型
//Usb 既可以接收手机变量又可以接收相机变量，Usb接口就体现了多态性
func (c Computer) Working(usb Usb) {
	usb.start()
	usb.stop()
}

func main() {
	computer := Computer{}
	phone := Phone{}
	camera := Camera{}
	var i integer
	//接口本身不能创建实例，但可以指向实现了该接口的自定义类型变量
	var u Usb = i
	u.start()

	computer.Working(i)
	computer.Working(phone)
	computer.Working(camera)
}

2.接口注意事项

package main

import "fmt"

type Ainterface interface {
	test01()
}
type Binterface interface {
	test02()
	test03() //方法一样，实现了就可以，实现接口只看函数，不看是哪个接口
}

//如果实现Cinterface,那么继承接口中的方法也要都实现
type Cinterface interface {
	Ainterface
	Binterface
	test03()
}
type Student struct {
}

func (s Student) test01() {
	fmt.Println("test()01")
}

func (s Student) test02() {

}

func (s Student) test03() {

}

type T interface {
}

func main() {
	var student Student
	//如果未能实现接口中的所有方法，赋值报错
	var c Cinterface = student
	c.test01()

	//任何变量都可以赋值给一个空接口
	var t T = student            //默认student实现了空接口
	fmt.Println(t)               //输出空接口{}
	var t2 interface{} = student //interface{} 等价 T
	fmt.Println(t2)
	var num = 8.8
	t = num
	fmt.Println(t)
}

3.类型断言

package main

import "fmt"

type Usb interface {
	start()
	stop()
}
type Phone struct {
	name string
}

func (p Phone) start() {
	fmt.Printf("%v手机开始工作\n", p.name)
}
func (p Phone) stop() {
	fmt.Println("手机停止工作")
}
func (p Phone) call() {
	fmt.Println("手机开始打电话")
}

type Camera struct {
	name string
}

func (c Camera) start() {
	fmt.Printf("%v相机开始工作\n", c.name)
}

func (c Camera) stop() {
	fmt.Println("相机停止工作")
}

type Computer struct {
}

func (c Computer) working(usb Usb) {
	usb.start()
	//如果usb指向phone结构体变量，则需要执行call方法
	//call方法是phone实现usb接口特有的方法
	u, ok := usb.(Phone)
	if ok {
		u.call()
	}
	usb.stop()
}

func main() {
	var a interface{}
	var t int = 10
	a = t //空接口可以接收任意类型
	var b int
	//b = a      报错

	//类型断言，表示判断a是否指向int类型的变量
	//如果是就转成point类型并赋值给b，否则报错
	//带自测，判断 a 是否能转换成int
	b, ok := a.(int)
	if ok {
		fmt.Printf("b的类型%T，值%v\n", b, b)
	} else {
		fmt.Println("转换失败")
	}
	fmt.Println("继续执行")

	var usb [3]Usb
	usb[0] = Phone{"三星"}
	usb[1] = Phone{"苹果"}
	usb[2] = Camera{"索尼"}
	var computer = Computer{}
	computer.working(usb[0])
	computer.working(usb[1])
	computer.working(usb[2])
}