Go语言基础第09天（面向对象多态接口断言）

1.面向对象计算器

type FuLei struct {
    
    
	num1 int
	num2 int
}
type JiaFaZiLei struct {
    
    
	FuLei
}
type JianFaZiLei struct {
    
    
	FuLei
}

type JieKou interface {
    
    
	JiSuan() int
}

func DuoTai(jiekou JieKou) (value int) {
    
    
	value = jiekou.JiSuan()
	return
}
func (jiafa *JiaFaZiLei) JiSuan() int {
    
    
	return jiafa.num1 + jiafa.num2
}

func (jianfa *JianFaZiLei) JiSuan() int {
    
    
	return jianfa.num1 - jianfa.num2
}

type GongChang struct {
    
    
}

func (gongchang *GongChang) JiSuanJieGuo(num1 int, num2 int, yunsuanfu string) (value int) {
    
    

	//创建接口变量
	var jiekou JieKou
	switch yunsuanfu {
    
    
	case "+":
		//创建对象
		var jiafa JiaFaZiLei = JiaFaZiLei{
    
    FuLei{
    
    num1, num2}}
		//value=jiafa.JiSuan()
		jiekou = &jiafa
	case "-":
		var jianfa JianFaZiLei = JianFaZiLei{
    
    FuLei{
    
    num1, num2}}
		//value=jianfa.JiSuan()
		jiekou = &jianfa
	}
	//value=jiekou.JiSuan()
	value = DuoTai(jiekou)
	return
}
func main01() {
    
    
	var gongchang GongChang
	value := gongchang.JiSuanJieGuo(10, 20, "-")
	fmt.Println(value)
}

2.接口的定义和使用

type person struct {
    
    
	name string
	sex  string
	age  int
}

type student struct {
    
    
	person
	score int
}

type teacher struct {
    
    
	person
	subject string
}

func (s *student) SayHello() {
    
    
	fmt.Printf("大家好，我是%s，我是%s生，我今年%d岁了，我的成绩是%d分\n", s.name, s.sex, s.age, s.score)
}
func (t *teacher) SayHello() {
    
    
	fmt.Printf("大家好，我是%s，我是%s生，我今年%d岁了，我叫的学科是%s\n", t.name, t.sex, t.age, t.subject)
}

// 1
// 接口定义
// 接口定义了规则   方法实现了规则
// 接口是虚的    方法是实的
// 格式 type  接口名  interface{方法列表}
// 方法名（参数列表）（返回值列表）
type Humaner interface {
    
    
	//2
	//方法 函数声明 没有具体实现  具体的实现要根据对象不同  实现方式也不同
	//接口中的方法必须有具体的实现
	SayHello()
}

func main02() {
    
    

	var stu student = student{
    
    person{
    
    "小明", "男", 18}, 100}
	var tea teacher = teacher{
    
    person{
    
    "法师", "女", 31}, "盗墓"}
	//3
	//定义接口类型
	//接口做了同一的处理 先实现接口  在根据接口实现对应的方法
	//在需求改变时 不需要改变接口 只需要修改方法
	var h Humaner

	//fmt.Println(h.SayHello)
	h = &stu
	h.SayHello()

	fmt.Printf("%p\n", h)
	h = &tea
	h.SayHello()

	fmt.Printf("%p\n", h)

	//stu.SayHello()
	//tea.SayHello()
}

3.多态实现

type person1 struct {
    
    
	name string
	sex  string
	age  int
}

type student1 struct {
    
    
	person1
	score int
}

type teacher1 struct {
    
    
	person1
	subject string
}

func (s *student1) SayHello() {
    
    
	fmt.Printf("大家好，我是%s，我是%s生，我今年%d岁了，我的成绩是%d分\n", s.name, s.sex, s.age, s.score)
}
func (t *teacher1) SayHello() {
    
    
	fmt.Printf("大家好，我是%s，我是%s生，我今年%d岁了，我叫的学科是%s\n", t.name, t.sex, t.age, t.subject)
}

// 接口实现
type Personer interface {
    
    
	SayHello()
}

// 多态实现
// 多态是将接口类型作为函数参数  多态实现接口的统一处理
func SayHello(p Personer) {
    
    
	p.SayHello()
}

func main03() {
    
    

	var p Personer

	p = &student1{
    
    person1{
    
    "小红", "女", 10}, 90}

	//p.SayHello()
	SayHello(p)

	p = &teacher1{
    
    person1{
    
    "一泓", "女", 18}, "心里辅导"}
	SayHello(p)
}

4.多态练习

// 1、接口的实现
type USBer interface {
    
    
	Read()
	Write()
}

// 2、创建对象
type USBDev struct {
    
    
	id     int
	name   string
	rspeed int
	wspeed int
}

type Mobile struct {
    
    
	USBDev
	call string
}

type Upan struct {
    
    
	USBDev
}

// 3、实现方法
func (m *Mobile) Read() {
    
    
	fmt.Printf("%s正在读取数据速度为：%d\n", m.name, m.rspeed)
}

func (m *Mobile) Write() {
    
    
	fmt.Printf("%s正在写入数据速度为：%d\n", m.name, m.wspeed)
}

func (u *Upan) Read() {
    
    
	fmt.Printf("%s正在读取数据速度为：%d\n", u.name, u.rspeed)
}

func (u *Upan) Write() {
    
    
	fmt.Printf("%s正在写入数据速度为：%d\n", u.name, u.wspeed)
}

// 4、多态实现  将接口作为函数参数
func UseDev(usb USBer) {
    
    
	usb.Read()
	usb.Write()
}

func main04() {
    
    
	//接口类型
	var usb USBer
	usb = &Mobile{
    
    USBDev{
    
    101, "手机", 5, 10}, "隔壁老王"}

	UseDev(usb)

	usb = &Upan{
    
    USBDev{
    
    102, "U盘", 20, 30}}
	UseDev(usb)

}

5.接口继承

// 接口
type Humaner1 interface {
    
     //子集
	SayHi()
}

// 接口
type Personer1 interface {
    
     //超集
	Humaner1 //一组子集的集合
	Sing(string)
}

type student3 struct {
    
    
	name string
	age  int
	sex  string
}

func (s *student3) SayHi() {
    
    
	fmt.Printf("大家好，我是%s，我今年%d岁了，我是%s生\n", s.name, s.age, s.sex)
}

func (s *student3) Sing(name string) {
    
    
	fmt.Printf("大家好，我叫%s,我给大家唱一首：%s\n", s.name, name)
}

func main05() {
    
    

	var h Humaner1 //子集
	h = &student3{
    
    "韩红", 40, "女"}
	h.SayHi()

	var p Personer1 //超集
	p = &student3{
    
    "王菲", 18, "女"}
	p.SayHi()
	p.Sing("传奇")

	//将超级转成子集  翻过来不允许
	h = p //ok
	//p=h//err

	p.SayHi()

}

6.空接口的定义和使用

func main0601() {
    
    
	//fmt.Println("hello")
	//fmt.Println(10)
	//fmt.Println(3.14)
	//fmt.Println(test)

	//空接口  可以接收任意类型数据
	var i interface{
    
    }
	i = 10
	fmt.Println(i)
	fmt.Printf("%p\n", &i)
	i = "hello world"
	fmt.Println(i)
	fmt.Printf("%p\n", &i)

	var arr [3]int = [3]int{
    
    1, 2, 3}
	i = arr
	fmt.Println(i)
	fmt.Printf("%p\n", &i)

}

func main06() {
    
    
	//空接口切片
	var i []interface{
    
    }
	//i:=make([]interface{},3)
	i = append(i, 1, 2, "hello", "你瞅啥", [3]int{
    
    1, 2, 3})

	//for j:=0;j<len(i);j++{
    
    
	//	fmt.Println(i[j])
	//}

	for idx, v := range i {
    
    
		fmt.Println(idx, v)
	}

}

7.类型断言

func main() {
    
    

	//var arr []interface{}
	arr := make([]interface{
    
    }, 5)
	arr[0] = 123
	arr[1] = 3.1456
	arr[2] = "hello"
	arr[3] = 1.234
	arr[4] = []int{
    
    1, 2, 3}

	fmt.Println(arr)
	for _, v := range arr {
    
    
		//对数据v进行类型断言
		//data,ok:=v.(int)
		//if ok{
    
    
		//	fmt.Println(data)
		//}
		if data, ok := v.(int); ok {
    
    
			fmt.Println("整型数据：", data)
		} else if data, ok := v.(float64); ok {
    
    
			fmt.Println("浮点型数据：", data)
		} else if data, ok := v.(string); ok {
    
    
			fmt.Println("字符串数据：", data)
		} else if data, ok := v.([]int); ok {
    
    
			fmt.Println("切片数据：", data)
		}
	}

}