Golang面向对象编程_多态and 类型断言

最新推荐文章于 2024-04-27 12:08:14 发布

从春到秋冬

最新推荐文章于 2024-04-27 12:08:14 发布

阅读量111

点赞数

分类专栏： Golang学习文章标签： golang 开发语言

本文链接：https://blog.csdn.net/tai_yang_yue/article/details/129436875

版权

Golang学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

多态

在Go语言，多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态。

接口体现多态的两种形式

多态参数：在Usb接口案例中， usb Usb既可以接收手机变量，又可以接收相机变量，这就体现了Usb接口多态
多态数组：演示案例。给Usb数组中，存放Phone结构体

package main
import "fmt"

//声明一个接口
type Usb interface{
	//声明了两个没有实现的方法
	Start()
	Stop()
}
//手机
type Phone struct{
	Name string
}

//让结构体实现Usb接口的方法
func(phone Phone)Start(){
	fmt.Println("手机开始工作")
}
func(phone Phone)Stop(){
	fmt.Println("手机停止工作")
}
//相机
type Camera struct{
	Name string 
}
//让相机camera也实现Usb接口的方法
func(camera Camera)Start(){
	fmt.Println("相机开始工作")
}
func(camera Camera)Stop(){
	fmt.Println("相机停止工作")
}
//计算机
type Computer struct{

}

//编写一个方法Working 方法，接收一个Usb接口类型变量
//只要实现了Usb接口（所谓实现Usb接口，就是指实现了 Usb接口声明所有方法）
func (computer 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{"小米"}
	usbArr[2] = Camera{"尼康"}
	fmt.Println(usbArr)
}

类型断言（assert）

引出

需求：
基本介绍
- 类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言

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

在进行类型断言时，如果类型不匹配，就会报 panic，因此进行类型断言时，要确保原来的空接口指向的就是要断言的类型
如何在进行断言时，带上检测机制，如果成功就OK，否则也不需要报一个panic

package main
import "fmt"

// type Point struct{
// 	x int
// 	y int
// }
func main(){
	var x interface{}
	var b float32 = 1.1
	x = b //空接口，可以接收任意类型
//带检测的类型断言
	if y, ok := x.(float32); ok {
		fmt.Println("convert success")
		fmt.Printf("y 的类型是%T 值是= %v", y, y)
	}else{
		fmt.Println("convert fail")
	}
	fmt.Println("继续执行")
}

类型断言最佳实践

一：对之前的Usb接口案例做改进，给Phone结构体增加一个特有的方法call()，当Usb接口接收的是Phone变量时，还需要调用call方法

package main
import "fmt"

//声明一个接口
type Usb interface{
	//声明了两个没有实现的方法
	Start()
	Stop()
}
//手机
type Phone struct{
	Name string
}

//让结构体实现Usb接口的方法
func(phone Phone)Start(){
	fmt.Println("手机开始工作")
}
func(phone Phone)Stop(){
	fmt.Println("手机停止工作")
}
//Call方法是手机特有的
func (phone Phone)Call(){
	fmt.Println("手机  开始打电话")
}
//相机
type Camera struct{
	Name string 
}
//让相机camera也实现Usb接口的方法
func(camera Camera)Start(){
	fmt.Println("相机开始工作")
}
func(camera Camera)Stop(){
	fmt.Println("相机停止工作")
}
//计算机
type Computer struct{

}

//编写一个方法Working 方法，接收一个Usb接口类型变量
//只要实现了Usb接口（所谓实现Usb接口，就是指实现了 Usb接口声明所有方法）
func (computer Computer)Working(usb Usb){
	//通过usb接口变量来调用Start和Stop方法
	usb.Start()
	//如果usb是指向Phone结构体变量，则还需要调用call方法
	//类型断言
	if phone, ok := usb.(Phone); ok{
		phone.Call()
	}
	usb.Stop()
}

func main(){
	//定义一个Usb接口数组，可以存放Phone和Camera的结构体变量
	//这里就体现出多态数组
	var computer Computer
	var usbArr [3]Usb
	usbArr[0] = Phone{"华为"}
	usbArr[1] = Phone{"小米"}
	usbArr[2] = Camera{"尼康"}
	//fmt.Println(usbArr)
	//除了调用Usb 接口声明的方法外，还需要调用Phone 特有方法 call
	for _, v := range usbArr{
		computer.Working(v)
	}
}

在这里插入图片描述

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

package main
import "fmt"

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

func main(){

	var n1 float32 = 1.1
	var n2 float64 = 3.14
	n3 := 200
	n4 := "tom"
	n5 := 50000
	TypeJudge(n1, n2, n3, n4, n5)

}

j结果

增加判断Student类型和 *Student类型

package main
import "fmt"

//定义了一个Student类型
type Student struct{

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



func main(){

	var n1 float32 = 1.1
	var n2 float64 = 3.14
	n3 := 200
	n4 := "tom"
	n5 := 50000
	var stu01 Student
	stu02 := &Student{}
	TypeJudge(n1, n2, n3, n4, n5, stu01, stu02)

}

在这里插入图片描述