GO语言学习之面向对象（5）之多态

GO语言学习之面向对象（5）之多态

10面向对象编程之多态

10.1基本介绍

变量（实例）具有多种形态。面向对象的三大特征，在Go语言，多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态

10.2快速入门

在前面的USB接口案例，Usb usb ,既可以接收手机变量，又可以接收相机变量，就体现了USB接口多态特性。

//编写一个方法 working,接收一个usb接口类型变量
//只要是实现了USB接口（所谓实现 USB接口，就是指实现了USB接口声明的所有方法）
func(c  Computer)Working(usb Usb){
	//usb变量会根据传入的实参，来判断到底是Phone，还是Camera
	//通过usb接口变量来调用Start和Stop方法
	usb.Start()
	usb.Stop()
}

10.3接口体现多态的两种方式

》多态参数

在前面的USB接口案例，USB usb 既可以接收手机变量，又可以接收相机变量，就体现了usb 接口多态

》多态数组

案例：给Usb数组中，存放Phone 结构体和 Camera 结构体变量

package main

import "fmt"

//声明定义一个接口
type Usb interface {
	//声明了两个没有实现的方法
	Start()
	Stop()
}
type Phone struct {
	name string
}
//让phone 实现 Usb 接口的方法
func (p Phone)Start(){
	fmt.Println("手机开机")
}
func (p Phone)Stop(){
	fmt.Println("手机关机")
}

type Camera struct {
	name string
}
//让 Camera 实现 Usb 接口的方法
func (c Camera)Start(){
	fmt.Println("相机开机")
}
func (c Camera)Stop(){
	fmt.Println("相机关机")
}


func main() {
	//定义一个Usb 接口·数组，可以存放Phone和 camera 结构体变量
	//这里就体现了多态数组
	var usbArr [3]Usb

	usbArr[0]=Phone{"锤子"}
	usbArr[1]=Phone{"坚果"}
	usbArr[2]=Camera{"尼康"}

	fmt.Println(usbArr)
}

11.面向对象之类型断言

11.1由一个具体的需要，引出了类型断言

package main
//需求：如何将一个接口变量，赋给自定义类型的变量==》引出类型断言
import "fmt"

//看一段代码
type Point struct {
	x int
	y int
}

func main() {
	var a interface{}
	var p Point=Point{10,100}
	a=p
	fmt.Println(a)
	var b Point
	b=a.(Point)
	fmt.Println(b)
}

//b=a.(Point)就是类型断言，表示判断 a 是否指向Point类型的变量，如果是就转成
//Point 类型并赋给b 变量，否则报错

11.2基本介绍

类型断言，由于接口时一般类型，不知道具体类型，如果要转成具体类型，

就需要使用类型断言

	var  x interface{}
	var y float32=1.1
	x=y//空接口可以接收任意类型
	b:=x.(float32)
	fmt.Printf("b的类型是 %T ，值是 =%v",b,b)

》对上面代码说明：

在进行类型断言时，如果类型不匹配，就会报panic ,因此进行类型断言时，要确保原来的空接口指向的就是断言的类型

》如何在进行断言时，带上检测机制，如果成功就ok,否则也不要报panic

	var  x interface{}
	var y float32=1.1
	x=y//空接口可以接收任意类型
	b:=x.(float32)
	fmt.Printf("b的类型是 %T ，值是 =%v",b,b)
	//类型断言（带检测的）
	if j,ok:=x.(float32);ok{
		fmt.Println("Success")
		fmt.Printf("j的类型是 %T 值是 %v",j,j)
		fmt.Println()
	}else {
		fmt.Println("fail")
	}

	fmt.Println("GO ON")

11.3类型断言的最佳实践1

》在前面的Usb接口案例做改进

给Phone 结构体增加一个特有的方法call(),当 Usb接口接收的是Phone 变量时，还需要调用 call方法，走代码

package main

import "fmt"

//定义一个接口
type Usb interface {
	//声明了两个没有实现的方法
	Start()
	Stop()
}
type Phone struct {
	name string
}
//让 Phone 实现 Usb 接口的方法
func (p Phone)Start(){
	fmt.Println("手机开始工作。。。。")
}
func (p Phone)Stop(){
	fmt.Println("手机停止工作。。。。")
}
func (p Phone)Call(){
	fmt.Println("手机在打电话。。。")
}
//定义 camera结构体
type Camera struct{
	name string
}
//让 Camera 实现 Usb 接口的方法
func (c Camera)Start(){
	fmt.Println("相机开始工作。。。。")
}
func (c Camera)Stop(){
	fmt.Println("相机停止工作。。。。。")
}

//定义计算机结构体
type  Computer struct {

}

func (Computer Computer)Working(usb Usb){
	usb.Start()
	//如果 usb 是指向Phone 结构体变量，则还需要调用 call（）方法
	//类型断言
	if phone,ok:=usb.(Phone);ok{
		phone.Call()
	}
	usb.Stop()
}

func main() {

	//定义一个 Usb接口数组，可以存放 Phone和 Camera 的结构体变量
	//这里就体现出多态数组
	var usbArr [3]Usb
	usbArr[0]=Phone{"坚果"}
	usbArr[1]=Phone{"锤子"}
	usbArr[2]=Camera{"尼康"}

	//遍历usbArr
	//Phone 还有一个特有的方法 call(),请遍历Usb数组，如果是Phone变量
	//除了调用 Usb接口声明的方法外，还需要调用Phone特有方法call
	var computer  Computer
	for _,v:=range usbArr{
		computer.Working(v)
		fmt.Println()
	}

}

11.4类型断言的最佳实践2

写一函数，循环判断传入参数的类型：

package main

import "fmt"

//编写一个函数，可以判断输入的参数是什么类型
func TypeJudge(items...interface{})  {
	
	for index,x :=range items{
		switch x.(type) {
		case bool:
			fmt.Printf("第%v个参数是 bool 类型，值是%v\n",index,x)
		case float32:
			fmt.Printf("第%v个参数是 float32 类型，值是%v\n",index,x)
		case float64:
			fmt.Printf("第%v个参数是 float64 类型，值是%v\n",index,x)
		case int,int32,int64:
			fmt.Printf("第%v个参数是 整数类型，值是%v\n",index,x)
		case string:
			fmt.Printf("第%v个参数是 STRING 类型，值是%v\n",index,x)
		default:
			fmt.Printf("第%v个参数类型不确定，值是%v\n",index,x)
		}
	}

}
func main() {
	var n1 float32=1.1
	var n2 float64  =3.14
	var n3 int32=30
	var name string="peter"
	address:="beijing"
	n4:=1000

	TypeJudge(n1,n2,n3,n4,name,address)
}

11.5类型断言的最佳实践 3

在前面代码基础上，增加判断Student类型 和 *Student类型

//编写一个函数，可以判断输入的参数是什么类型
func TypeJudge(items...interface{})  {
	
	for index,x :=range items{
		switch x.(type) {
		case bool:
			fmt.Printf("第%v个参数是 bool 类型，值是%v\n",index,x)
		case float32:
			fmt.Printf("第%v个参数是 float32 类型，值是%v\n",index,x)
		case float64:
			fmt.Printf("第%v个参数是 float64 类型，值是%v\n",index,x)
		case int,int32,int64:
			fmt.Printf("第%v个参数是 整数类型，值是%v\n",index,x)
		case string:
			fmt.Printf("第%v个参数是 STRING 类型，值是%v\n",index,x)
		case Student:
			fmt.Printf("第%v个参数是 STRING 类型，值是%v\n",index,x)
		case *Student:
			fmt.Printf("第%v个参数是 STRING 类型，值是%v\n",index,x)
		default:
			fmt.Printf("第%v个参数类型不确定，值是%v\n",index,x)
		}
	}

}