golang面向对象之多态

1、基本介绍

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

2、快速入门

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

//编写一个Working方法，接收一个usb接口类型变量
//只要实现了usb接口，usb变量会根据传入的参数来判断到底是phone还是camera
func (c Computer) Working(usb Usb) {
	//通过usb接口变量来调用start和stop方法
	usb.Start()
	usb.Stop()
}

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("相机停止工作...")
}

//计算机
type Computer struct {
}

//编写一个Working方法，接收一个usb接口类型变量
//只要实现了usb接口，usb变量会根据传入的参数来判断到底是phone还是camera
func (c Computer) Working(usb Usb) {
	//通过usb接口变量来调用start和stop方法
	usb.Start()
	usb.Stop()
}
func main{
	//定义一个Usb接口数组，可以存放phone和camera的结构体变量
	//这里就体现出多态数组
	var usbArr[3]Usb
	usbArr[0]=Phone{"华为"}
	usbArr[1]=Phone{"vivo"}
	usbArr[2]=Camera{"尼康"}
	fmt.Println(usbArr)
}

4、类型断言

  类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言, 具体的如下:

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

➢对上面代码的说明:
  在进行类型断言时，如果类型不匹配，就会报panic,因此进行类型断言时，要确保原来的空接口指向的就是断言的类型.
➢如何在进行断言时，带上检测机制，如果成功就ok,否则也不要报panic

//类型断言案例（带检测的）
	var x interface{}
	var b2 float64 = 1.1
	x = b2 //空接口，可以接收任意类型
	//类型断言
	if y, ok := x.(float64); ok {
		fmt.Printf("convert success")
		fmt.Printf("y的类型是%T 值是=%v", y, x)
	} else {
		fmt.Printf("convert fail")
	}
	fmt.Printf("继续执行。。。。")

类型断言实践1
➢在前面的 Usb接口案例做改进:
  给Phone结构体增加一一个特有的方法all),当Usb接口接收的是Phone变量时，还需要调用call方法。

//声明/定义一个接口
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("手机在打电话...")
}
type Camera struct {
	name string
}

//让Camera实现Usb接口方法
func (c Camera) Start() {
	fmt.Println("相机开始工作...")
}
func (c Camera) Stop() {
	fmt.Println("相机停止工作...")
}

//计算机
type Computer struct {
}

//编写一个Working方法，接收一个usb接口类型变量
//只要实现了usb接口，usb变量会根据传入的参数来判断到底是phone还是camera
func (c Computer) Working(usb Usb) {
	//通过usb接口变量来调用start和stop方法
	usb.Start()
	//如果usb是指向Phone结构体变量，则还需要调用call方法
	//类型断言
	if phone,ok:=usb.(Phone);ok{
		phone.Call()
	}
	usb.Stop()
}
func main{
	var usbArr [3]Usb
	usbArr[0] = Phone{"华为"}
	usbArr[1] = Phone{"vivo"}
	usbArr[2] = Camera{"尼康"}
	fmt.Println(usbArr)
	//遍历usbArr
	var computer1 Computer
	for _,v:=range usbArr{
		computer1.Working(v)
		fmt.Println()
	}
}

类型断言实践2
  写一个函数，循环判断传入参数的类型

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个参数是int类型，值是%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 = 2.2
	var n3 int32 = 52
	var name string = "tom"
	address := "北京"
	n4 := 200
	TypeJudge(n1, n2, n3, name, address, n4)
}