【golang学习总结】11 golang面向对象编程

最新推荐文章于 2023-01-06 21:58:07 发布

ccong...

最新推荐文章于 2023-01-06 21:58:07 发布

阅读量550

点赞数

分类专栏： golang学习总结文章标签： golang 面向对象

本文链接：https://blog.csdn.net/huyang_1995/article/details/114547129

版权

golang学习总结专栏收录该内容

12 篇文章 1 订阅

订阅专栏

本文介绍SpringBoot相关内容。和【跨考菌】一起加油吧~

在这里插入图片描述

如果你有收获，记得帮博主一键三连哦😊

1 结构体

1.1 golang面向对象编程说明

Golang 也支持面向对象编程(OOP)，但是和传统的面向对象编程有区别，并不是纯粹的面向对
象语言。所以我们说 Golang 支持面向对象编程特性是比较准确的。
Golang 没有类(class)， Go 语言的结构体(struct)和其它编程语言的类(class)有同等的地位，你可以理解 Golang 是基于 struct 来实现 OOP 特性的。
Golang 面向对象编程非常简洁，去掉了传统 OOP 语言的继承、方法重载、构造函数和析构函
数、隐藏的 this 指针等等
Golang 仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其它 OOP 语言不
一样，比如继承： Golang 没有 extends 关键字，继承是通过匿名字段来实现。
Golang 面向对象(OOP)很优雅， OOP 本身就是语言类型系统(type system)的一部分，通过接口
(interface)关联，耦合性低，也非常灵活。后面同学们会充分体会到这个特点。也就是说在 Golang 中面向接口编程是非常重要的特性。

1.2 结构体和结构体变量的关系图

在这里插入图片描述
说明：

将一类事物的特性提取出来(比如猫类)，形成一个新的数据类型，就是一个结构体。
通过这个结构体，我们可以创建多个变量(实例/对象)
事物可以猫类，也可以是 Person ， Fish 或是某个工具类。。。

1.3 简单案例

在这里插入图片描述

1.4 结构体和结构体变量的区别和联系

结构体是自定义的数据类型，代表一类事物.
结构体变量(实例)是具体的，实际的，代表一个具体变量

1.5 结构体内存布局

在这里插入图片描述

1.6 如何声明结构体

基本语法

type 结构体名称 struct {
	field1 type
	field2 type
}

举例:

type Student struct {
	Name string //字段
	Age int //字段
	Score float32
}

1.7 字段/属性

1.7.1 基本介绍

从概念或叫法上看： 结构体字段 = 属性 = field （即授课中，统一叫字段)
字段是结构体的一个组成部分，一般是基本数据类型、数组,也可是引用类型。比如我们前面定
义猫结构体的 Name string 就是属性

注意事项和细节说明

字段声明语法同变量，示例： 字段名字段类型
字段的类型可以为：基本类型、数组或引用类型
在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值(默认值)，规则同前面讲的
一样:
布尔类型是 false ，数值是 0 ，字符串是 “”。
数组类型的默认值和它的元素类型相关，比如 score [3]int 则为[0, 0, 0]
指针， slice，和 map 的零值都是 nil ，即还没有分配空间。
案例演示：

package main
import (
	"fmt"
)

//如果结构体的字段类型是: 指针，slice，和map的零值都是 nil ，即还没有分配空间
//如果需要使用这样的字段，需要先make，才能使用.

type Person struct{
	Name string
	Age int
	Scores [5]float64
	ptr *int //指针 
	slice []int //切片
	map1 map[string]string //map
}

type Monster struct{
	Name string
	Age int
}


func main() {

	//定义结构体变量
	var p1 Person
	fmt.Println(p1)

	if p1.ptr == nil {
		fmt.Println("ok1")
	}

	if p1.slice == nil {
		fmt.Println("ok2")
	}

	if p1.map1 == nil {
		fmt.Println("ok3")
	}

	//使用slice, 再次说明，一定要make
	p1.slice = make([]int, 10)
	p1.slice[0] = 100 //ok

	//使用map, 一定要先make
	p1.map1 = make(map[string]string)
	p1.map1["key1"] = "tom~" 
	fmt.Println(p1)

不同结构体变量的字段是独立，互不影响，一个结构体变量字段的更改，不影响另外一个, 结构体是值类型!!!
案例：

1.8 创建结构体变量和访问结构体字段

方式 1-直接声明
案例演示: var person Person

方式 2-{}
案例演示: var person Person = Person{}
在这里插入图片描述

方式 3-&
案例: var person *Person = new (Person)
在这里插入图片描述
方式 4-{}
案例: var person *Person = &Person{}

说明:

第 3 种和第 4 种方式返回的是结构体指针。
结构体指针访问字段的标准方式应该是： (*结构体指针).字段名 ，比如 (*person).Name = "tom"
但 go 做了一个简化，也支持结构体指针.字段名, 比如 person.Name = “tom”。更加符合程序员
使用的习惯， go 编译器底层 *对 person.Name 做了转化 (person).Name。

1.9 struct类型的内存分配机制

先来看一个思考题
基本说明
结构体在内存中示意图
看下面的代码，分析原因

上述代码内存分析：
分析下面代码错误原因

1.10 结构体使用细节

结构体的所有字段在内存中是连续的
结构体是用户单独定义的类型，和其它类型进行转换时需要有完全相同的字段(名字、个数和类
型)
结构体进行 type 重新定义(相当于取别名)， Golang 认为是新的数据类型，但是相互间可以强转
struct 的每个字段上，可以写上一个 tag, 该 tag 可以通过反射机制获取，常见的使用场景就是序
列化和反序列化。

序列化的使用场景:

在这里插入图片描述

2 方法

2.1 基本介绍

在某些情况下，我们要需要声明(定义)方法。 比如 Person 结构体:除了有一些字段外( 年龄，姓名…),Person 结构体还有一些行为,比如:可以说话、跑步…,通过学习，还可以做算术题。这时就要用方法才能完成。
Golang 中的方法是作用在指定的数据类型上的(即：和指定的数据类型绑定)， 因此自定义类型，都可以有方法，而不仅仅是 struct。

2.2 方法的声明和调用

在这里插入图片描述
语法说明：

func (a A) test() {} 表示 A 结构体有一方法，方法名为 test
(a A) 体现 test 方法是和 A 类型绑定的

举例说明：
在这里插入图片描述
总结：

test 方法和 Person 类型绑定
test 方法只能通过 Person 类型的变量来调用，而不能直接调用，也不能使用其它类型变量来调
用
func (p Person) test() {}… p 表示哪个 Person 变量调用，这个 p 就是它的副本, 这点和函数传参非
常相似。
p 这个名字，有程序员指定，不是固定, 比如修改成 person 也是可以

2.3 方法入门

给 Person 结构体添加 speak 方法,输出 xxx 是一个好人
给 Person 结构体添加 jisuan 方法,可以计算从 1+…+1000 的结果, 说明方法体内可以函数一样，
进行各种运算
给 Person 结构体 jisuan2 方法,该方法可以接收一个数 n，计算从 1+…+n 的结果
给 Person 结构体添加 getSum 方法,可以计算两个数的和，并返回结果
方法的调用

2.4 方法的声明/定义

func (recevier type) methodName（参数列表） (返回值列表){
	方法体
	return 返回值
}

参数列表：表示方法输入
recevier type : 表示这个方法和 type 这个类型进行绑定，或者说该方法作用于 type 类型
receiver type : type 可以是结构体，也可以其它的自定义类型
receiver : 就是 type 类型的一个变量(实例)，比如： Person 结构体的一个变量(实例)
返回值列表：表示返回的值，可以多个
方法主体：表示为了实现某一功能代码块
return 语句不是必须的

2.5 使用细节

结构体类型是值类型，在方法调用中，遵守值类型的传递机制， 是值拷贝传递方式
如程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理
Golang 中的方法作用在指定的数据类型上的(即：和指定的数据类型绑定)，因此自定义类型，
都可以有方法，而不仅仅是 struct，比如 int , float32 等都可以有方法
方法的访问范围控制的规则，和函数一样。方法名首字母小写，只能在本包访问，方法首字母
大写，可以在本包和其它包访问。 [讲解]
如果一个类型实现了 String()这个方法，那么 fmt.Println 默认会调用这个变量的 String()进行输出

2.6 方法和函数的区别

1) 调用方式不一样
函数的调用方式: 函数名(实参列表)
方法的调用方式: 变量.方法名(实参列表)
2) 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然
在这里插入图片描述
3) 对于方法（如 struct 的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反
过来同样也可以

总结：

不管调用形式如何， 真正决定是值拷贝还是地址拷贝，看这个方法是和哪个类型绑定.
*如果是和值类型，比如 (p Person) , 则是值拷贝，如果和指针类型，比如是 (p Person) 则
是地址拷贝。

3 工厂模式

3.1 说明

Golang 的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。

3.2 先看一个需求

在这里插入图片描述

3.3 工厂模式如何解决这个问题呢？

使用工厂模式实现跨包创建结构体实例(变量)的案例:
如果 model 包的结构体变量首字母大写，引入后，直接使用, 没有问题
在这里插入图片描述
如果 model 包的结构体变量首字母小写，引入后，不能直接使用, 可以工厂模式解决，看代码:
student.go

main.go

3.4 思考

如果 model 包的 student 的结构体的字段 Score 改成 score，我们还能正常访问
吗？又应该如何解决这个问题呢？
在这里插入图片描述

4 面向对象编程三大特性-封装

4.1 封装的好处

隐藏实现细节
提可以对数据进行验证，保证安全合理(Age)

如何体现封装呢？

对结构体中的属性进行封装
通过方法，包实现封装

4.2 封装实现步骤

将结构体、字段(属性)的首字母小写(不能导出了，其它包不能使用，类似 private)
给结构体所在包提供一个工厂模式的函数，首字母大写。类似一个构造函数
提供一个首字母大写的 Set 方法(类似其它语言的 public)，用于对属性判断并赋值

func (var 结构体类型名) SetXxx(参数列表) (返回值列表) {
	//加入数据验证的业务逻辑
	var.字段 = 参数
}

提供一个首字母大写的 Get 方法(类似其它语言的 public)，用于获取属性的值

func (var 结构体类型名) GetXxx() {
	return var.age;
}

特别说明：在 Golang 开发中并没有特别强调封装，这点并不像 Java. 所以提醒学过 java 的朋友，不用总是用 java 的语法特性来看待 Golang, Golang 本身对面向对象的特性做了简化的.

4.3 简单案例

请大家看一个程序(person.go),不能随便查看人的年龄,工资等隐私，并对输入的年龄进行合理的验证。设计: model 包(person.go) main 包(main.go 调用 Person 结构体)
model/person.go

package model
import "fmt"

type person struct {
	Name string
	age int   //其它包不能直接访问..
	sal float64
}

//写一个工厂模式的函数，相当于构造函数
func NewPerson(name string) *person {
	return &person{
		Name : name,
	}
}

//为了访问age 和 sal 我们编写一对SetXxx的方法和GetXxx的方法
func (p *person) SetAge(age int) {
	if age >0 && age <150 {
		p.age = age
	} else {
		fmt.Println("年龄范围不正确..")
		//给程序员给一个默认值
	}
}

func (p *person) GetAge() int {
	return p.age
}


func (p *person) SetSal(sal float64) {
	if sal >= 3000 && sal <= 30000 {
		p.sal = sal
	} else {
		fmt.Println("薪水范围不正确..")
		
	}
}

func (p *person) GetSal() float64 {
	return p.sal
}

main/main.go

package main
import (
	"fmt"
	"test/chapter11/encapsulate/model"
)

func main() {

	p := model.NewPerson("smith")
	p.SetAge(18)
	p.SetSal(5000)
	fmt.Println(p)
	fmt.Println(p.Name, " age =", p.GetAge(), " sal = ", p.GetSal())
	
}

4.4 案例2

创建程序,在 model 包中定义 Account 结构体： 在 main 函数中体会 Golang 的封装性。
Account 结构体要求具有字段：账号（长度在 6-10 之间）、余额(必须>20)、密码（必须是六
通过 SetXxx 的方法给 Account 的字段赋值。
在 main 函数中测试

model/account.go

package model

import (
	"fmt"
)
//定义一个结构体account
type account struct {
	accountNo string
	pwd string
	balance float64
}

//工厂模式的函数-构造函数
func NewAccount(accountNo string, pwd string, balance float64) *account {

	if len(accountNo) < 6 || len(accountNo) > 10 {
		fmt.Println("账号的长度不对...")
		return nil
	}

	if len(pwd) != 6 {
		fmt.Println("密码的长度不对...")
		return nil
	}

	if balance < 20 {
		fmt.Println("余额数目不对...")
		return nil
	}

	return &account{
		accountNo : accountNo,
		pwd : pwd,
		balance : balance,
	}

}

//方法
//1. 存款
func (account *account) Deposite(money float64, pwd string)  {

	//看下输入的密码是否正确
	if pwd != account.pwd {
		fmt.Println("你输入的密码不正确")
		return 
	}

	//看看存款金额是否正确
	if money <= 0 {
		fmt.Println("你输入的金额不正确")
		return 
	}

	account.balance += money
	fmt.Println("存款成功~~")

}

//取款
func (account *account) WithDraw(money float64, pwd string)  {

	//看下输入的密码是否正确
	if pwd != account.pwd {
		fmt.Println("你输入的密码不正确")
		return 
	}

	//看看取款金额是否正确
	if money <= 0  || money > account.balance {
		fmt.Println("你输入的金额不正确")
		return 
	}

	account.balance -= money
	fmt.Println("取款成功~~")

}

//查询余额
func (account *account) Query(pwd string)  {

	//看下输入的密码是否正确
	if pwd != account.pwd {
		fmt.Println("你输入的密码不正确")
		return 
	}

	fmt.Printf("你的账号为=%v 余额=%v \n", account.accountNo, account.balance)

}

main/main.go

package main

import (
	"fmt"
	"test/chapter11/encapexercise/model"
)

func main() {
	//创建一个account变量
	account := model.NewAccount("jzh11111", "000", 40)
	if account != nil {
		fmt.Println("创建成功=", account)
	} else {
		fmt.Println("创建失败")
	}
}

5 面向对象编程三大特性-继承

5.1 为什么需要继承呢？

先看一个例子：
看个学生考试系统的程序 extends01.go，提出代码复用的问题

package main

import (
	"fmt"
)




//编写一个学生考试系统

type Student struct {
	Name string
	Age int
	Score int
}

//将Pupil 和 Graduate 共有的方法也绑定到 *Student
func (stu *Student) ShowInfo() {
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n", stu.Name, stu.Age, stu.Score)
}
func (stu *Student) SetScore(score int) {
	//业务判断
	stu.Score = score
}

//给 *Student 增加一个方法，那么 Pupil 和 Graduate都可以使用该方法
func (stu *Student) GetSum(n1 int, n2 int) int {
	return n1 + n2
}

//小学生
type Pupil struct { 
	Student //嵌入了Student匿名结构体
}

//显示他的成绩

//这时Pupil结构体特有的方法，保留
func (p *Pupil) testing() {
	fmt.Println("小学生正在考试中.....")
}

//大学生, 研究生。。


//大学生
type Graduate struct {
	Student //嵌入了Student匿名结构体
}

//显示他的成绩
//这时Graduate结构体特有的方法，保留
func (p *Graduate) testing() {
	fmt.Println("大学生正在考试中.....")
}

//代码冗余.. 高中生....

func main() {

	//当我们对结构体嵌入了匿名结构体使用方法会发生变化
	pupil := &Pupil{}
	pupil.Student.Name = "tom~"
	pupil.Student.Age = 8
	pupil.testing() 
	pupil.Student.SetScore(70)
	pupil.Student.ShowInfo()
	fmt.Println("res=", pupil.Student.GetSum(1, 2))


	graduate := &Graduate{}
	graduate.Student.Name = "mary~"
	graduate.Student.Age = 28
	graduate.testing() 
	graduate.Student.SetScore(90)
	graduate.Student.ShowInfo()
	fmt.Println("res=", graduate.Student.GetSum(10, 20))
}

对上面代码的小结

Pupil 和 Graduate 两个结构体的字段和方法几乎，但是我们却写了相同的代码，代码复用性不
强
出现代码冗余，而且代码不利于维护，同时也不利于功能的扩展。
解决方法-通过继承方式来解决

5.2 继承的示意图

在这里插入图片描述
也就是说：在 Golang 中，如果一个 struct 嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性。

5.3 嵌套匿名构造体的基本语法

在这里插入图片描述

5.4 使用案例

对上述冗余的代码利用继承来改进：

package main

import (
	"fmt"
)




//编写一个学生考试系统

type Student struct {
	Name string
	Age int
	Score int
}

//将Pupil 和 Graduate 共有的方法也绑定到 *Student
func (stu *Student) ShowInfo() {
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n", stu.Name, stu.Age, stu.Score)
}
func (stu *Student) SetScore(score int) {
	//业务判断
	stu.Score = score
}

//给 *Student 增加一个方法，那么 Pupil 和 Graduate都可以使用该方法
func (stu *Student) GetSum(n1 int, n2 int) int {
	return n1 + n2
}

//小学生
type Pupil struct { 
	Student //嵌入了Student匿名结构体
}

//显示他的成绩

//这时Pupil结构体特有的方法，保留
func (p *Pupil) testing() {
	fmt.Println("小学生正在考试中.....")
}

//大学生, 研究生。。


//大学生
type Graduate struct {
	Student //嵌入了Student匿名结构体
}

//显示他的成绩
//这时Graduate结构体特有的方法，保留
func (p *Graduate) testing() {
	fmt.Println("大学生正在考试中.....")
}

//代码冗余.. 高中生....

func main() {

	//当我们对结构体嵌入了匿名结构体使用方法会发生变化
	pupil := &Pupil{}
	pupil.Student.Name = "tom~"
	pupil.Student.Age = 8
	pupil.testing() 
	pupil.Student.SetScore(70)
	pupil.Student.ShowInfo()
	fmt.Println("res=", pupil.Student.GetSum(1, 2))


	graduate := &Graduate{}
	graduate.Student.Name = "mary~"
	graduate.Student.Age = 28
	graduate.testing() 
	graduate.Student.SetScore(90)
	graduate.Student.ShowInfo()
	fmt.Println("res=", graduate.Student.GetSum(10, 20))
}

发现，继承给编程带来下面的便利：

代码的复用性提高了
代码的扩展性和维护性提高了

5.5 继承的深入

结构体可以使用嵌套匿名结构体所有的字段和方法，即：首字母大写或者小写的字段、方法，
都可以使用。【举例说明】
匿名结构体字段访问可以简化，如图

对上面的代码小结
(1) 当我们直接通过 b 访问字段或方法时，其执行流程如下比如 b.Name
(2) 编译器会先看 b 对应的类型有没有 Name, 如果有，则直接调用 B 类型的 Name 字段
(3) 如果没有就去看 B 中嵌入的匿名结构体 A 有没有声明 Name 字段，如果有就调用,如果没有
继续查找…如果都找不到就报错.
当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问，如希望访问
匿名结构体的字段和方法，可以通过匿名结构体名来区分【举例说明】
结构体嵌入两个(或多个)匿名结构体，如两个匿名结构体有相同的字段和方法(同时结构体本身
没有同名的字段和方法)，在访问时，就必须明确指定匿名结构体名字，否则编译报错。【举例说明】
如果一个 struct 嵌套了一个有名结构体，这种模式就是组合，如果是组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字
嵌套匿名结构体后，也可以在创建结构体变量(实例)时，直接指定各个匿名结构体字段的值

在这里插入图片描述

5.6 案例剖析

结构体的匿名字段是基本数据类型，如何访问, 下面代码输出什么
在这里插入图片描述
说明

如果一个结构体有 int 类型的匿名字段，就不能第二个。
如果需要有多个 int 的字段，则必须给 int 字段指定名字

5 面向对象编程三大特性-多重继承

多重继承说明
如一个 struct 嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方
法，从而实现了多重继承。
案例演示
通过一个案例来说明多重继承使用

多重继承细节说明

如嵌入的匿名结构体有相同的字段名或者方法名，则在访问时，需要通过匿名结构体类型名来
区分。【案例演示】
为了保证代码的简洁性，建议大家尽量不使用多重继承

6 接口

在 Golang 中多态特性主要是通过接口来体现的。

6.1 接口入门案例

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("手机 在打电话..")
}


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{"vivo"}
	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()
	}
	//fmt.Println(usbArr)
}

6.2 接口基本语法

在这里插入图片描述

小结说明:

接口里的所有方法都没有方法体，即接口的方法都是没有实现的方法。接口体现了程序设计的
多态和高内聚低偶合的思想。
Golang 中的接口，不需要显式的实现。只要一个变量，含有接口类型中的所有方法，那么这个
变量就实现这个接口。因此， Golang 中没有 implement 这样的关键字

6.3 注意事项和细节

接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量(实例)
接口中所有的方法都没有方法体,即都是没有实现的方法。
在 Golang 中，一个自定义类型需要将某个接口的所有方法都实现，我们说这个自定义类型实现
了该接口。
一个自定义类型只有实现了某个接口，才能将该自定义类型的实例(变量)赋给接口类型
只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型。

在这里插入图片描述
6) 一个自定义类型可以实现多个接口

7) Golang 接口中不能有任何变量

8) 一个接口(比如 A 接口)可以继承多个别的接口(比如 B,C 接口)，这时如果要实现 A 接口，也必须将 B,C 接口的方法也全部实现。

package main
import (
	"fmt"
)

type BInterface interface {
	test01()
}

type CInterface interface {
	test02()
}

type AInterface interface {
	BInterface
	CInterface
	test03()
}

//如果需要实现AInterface,就需要将BInterface CInterface的方法都实现
type Stu struct {
}
func (stu Stu) test01() {

}
func (stu Stu) test02() {
	
}
func (stu Stu) test03() {
	
}
func main() {
	var stu Stu
	var a AInterface = stu
	a.test01()
}

interface 类型默认是一个指针(引用类型)，如果没有对 interface 初始化就使用，那么会输出 nil
空接口 interface{} 没有任何方法，所以所有类型都实现了空接口, 即我们可以把任何一个变量
赋给空接口。

type T  interface{

}

var t T = stu //ok
fmt.Println(t)
var t2 interface{}  = stu
var num1 float64 = 8.8
t2 = num1
t = num1
fmt.Println(t2, t)

6.4 案例

在这里插入图片描述

6.5 案例：实现对 Hero 结构体切片的排序: sort.Sort(data Interface)

package main
import (
	"fmt"
	"sort"
	"math/rand"
)

//1.声明Hero结构体
type  Hero struct{
	Name string
	Age int
}

//2.声明一个Hero结构体切片类型
type HeroSlice []Hero

//3.实现Interface 接口
func (hs HeroSlice) Len() int {
	return len(hs)
}

//Less方法就是决定你使用什么标准进行排序
//1. 按Hero的年龄从小到大排序!!
func (hs HeroSlice) Less(i, j int) bool {
	return hs[i].Age < hs[j].Age
	//修改成对Name排序
	//return hs[i].Name < hs[j].Name
}

func (hs HeroSlice) Swap(i, j int) {
	//交换
	// temp := hs[i]
	// hs[i] = hs[j]
	// hs[j] = temp
	//下面的一句话等价于三句话
	hs[i], hs[j] = hs[j], hs[i]
}


//1.声明Student结构体
type  Student struct{
	Name string
	Age int
	Score float64
}

//将Student的切片，安Score从大到小排序!!

func main() {

	//先定义一个数组/切片
	var intSlice = []int{0, -1, 10, 7, 90}
	//要求对 intSlice切片进行排序
	//1. 冒泡排序...
	//2. 也可以使用系统提供的方法 
	sort.Ints(intSlice) 
	fmt.Println(intSlice)

	//请大家对结构体切片进行排序
	//1. 冒泡排序...
	//2. 也可以使用系统提供的方法

	//测试看看我们是否可以对结构体切片进行排序
	var heroes HeroSlice
	for i := 0; i < 10 ; i++ {
		hero := Hero{
			Name : fmt.Sprintf("英雄|%d", rand.Intn(100)),
			Age : rand.Intn(100),
		}
		//将 hero append到 heroes切片
		heroes = append(heroes, hero)
	}

	//看看排序前的顺序
	for _ , v := range heroes {
		fmt.Println(v)
	}

	//调用sort.Sort
	sort.Sort(heroes)
	fmt.Println("-----------排序后------------")
	//看看排序后的顺序
	for _ , v := range heroes {
		fmt.Println(v)
	}

	i := 10
	j := 20
	i, j = j, i
	fmt.Println("i=", i, "j=", j) // i=20 j = 10
}

7 实现接口vs继承

package main
import (
	"fmt"
)

//Monkey结构体
type Monkey struct {
	Name string
}

//声明接口
type BirdAble interface {
	Flying()
}

type FishAble interface {
	Swimming()
}

func (this *Monkey) climbing() {
	fmt.Println(this.Name, " 生来会爬树..")
}

//LittleMonkey结构体
type LittleMonkey struct {
	Monkey //继承
}


//让LittleMonkey实现BirdAble
func (this *LittleMonkey) Flying() {
	fmt.Println(this.Name, " 通过学习，会飞翔...")
}

//让LittleMonkey实现FishAble
func (this *LittleMonkey) Swimming() {
	fmt.Println(this.Name, " 通过学习，会游泳..")
}

func main() {

	//创建一个LittleMonkey 实例
	monkey := LittleMonkey{
		Monkey {
			Name : "悟空",
		},
	}
	monkey.climbing()
	monkey.Flying()
	monkey.Swimming()

}

代码说明：

当 A 结构体继承了 B 结构体，那么 A 结构就自动的继承了 B 结构体的字段和方法，并且可以直
接使用
当 A 结构体需要扩展功能，同时不希望去破坏继承关系，则可以去实现某个接口即可，因此我
们可以认为： 实现接口是对继承机制的补充.

接口和继承解决的解决的问题不同
继承的价值主要在于：解决代码的复用性和可维护性。
接口的价值主要在于：设计，设计好各种规范(方法)，让其它自定义类型去实现这些方法。
接口比继承更加灵活 Person Student BirdAble LittleMonkey
接口比继承更加灵活，继承是满足 is - a 的关系，而接口只需满足 like - a 的关系。
接口在一定程度上实现代码解耦

8 类型断言

在这里插入图片描述

8.1 基本介绍

类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言，具体的如下:
在这里插入图片描述

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

8.2 类型断言案例1

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

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

在这里插入图片描述

8.2 类型断言案例2

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

package main
import (
	"fmt"
)


//定义Student类型
type Student struct {

}

//编写一个函数，可以判断输入的参数是什么类型
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个参数是 Student 类型，值是%v\n", index, x)
			case *Student :
				fmt.Printf("第%v个参数是 *Student 类型，值是%v\n", index, x)
			default :
				fmt.Printf("第%v个参数是  类型 不确定，值是%v\n", index, x)
		}
	}
}




func main() {

	var n1 float32 = 1.1
	var n2 float64 = 2.3
	var n3 int32 = 30
	var name string = "tom"
	address := "北京"
	n4 := 300

	stu1 := Student{}
	stu2 := &Student{}

	TypeJudge(n1, n2, n3, name, address, n4, stu1, stu2)


}