面向对象编程三大特性
基本介绍
Golang仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其他OOP语言不一样。
封装
面向对象编程思想-抽象
我们在前面去定义一个结构体的时候，实际上就是把一类事物共有的属性（字段）和行为（方法）提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。
package main import ( "fmt" ) // 定义一个结构体 type Account struct{ AccountNo string Pwd string Banlance float64 } // 方法 // 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) } func main(){ // 测试 account := Account{ AccountNo:"gs111", Pwd:"666666", Balance:100.0 } account.Query("666666") account.Deposite(200.0,"666666") account.Query("666666") account.Withdraw(20.0,"666666") account.Query("666666") }
封装介绍
封装就是把抽象出的字段和对应的操作封装在一起，数据被保护在内部，程序的其他包只有通过被授权的操作方法，才能对字段进行操作
优点
- 隐藏实现细节
- 可以对数据进行验证，保证安全合理
实现
1.对结构体中的属性进行封装
2. 通过方法，包 实现封装
实现步骤
- 将结构体，字段（属性）的首字母小写（不能导出了，其他包不能使用，类似private）
- 给结构体所在包提供一个工厂模式的函数，首字母大写，类似一个构造函数
3 . 提供一个首字母大写的Set方法{类似其他语言的public}，用于对属性判断并赋值
func (var 结构体类型名）SetXxx(参数列表）（返回值列表）{ // 加入数据验证的业务逻辑 var 字段 = 参数 }
4 . 提供一个首字母大写的Get方法（类似其他语言的public），用于获取属性的值
func (var 结构体类型名) GetXxx(){ return var.age; }
说明：在Golang开发中并没有特别强调封装，这点并不像Java，所以提醒学过Java的朋友不用总是用Java的特性来看待Golang，Golang本身对面向对象的特性做了简化的
案例
// 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.go import ( "fmt" "go_code/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()) }
练习
要求：
- 创建程序，在model包中定义Account结构体：在main函数中体会Golang的封装性
- Account结构体要求具有字段：账号（长队在6-10之间），余额（必须>20），密码（必须是六位）
- 通过SetXxx的方法给Account的字段赋值。
- 在main函数中测试
package model import ( "fmt" ) // 定义一个结构体 type account struct{ accountNo string pwd string banlance 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) }
package main import ( "fmt" "go_code/chapter11/encapexercise/model" ) func main(){ // 创建一个account变量 account := model.NewAccount("jzh111111","999999",40) if account != nil{ fmt.Println("创建成功=",account) }else{ fmt.Println("创建失败") } }
继承
继承可以解决代码复用，让我们的编程更加靠近人类思维。
当多个结构体存在相同的属性（字段）和方法，只需嵌入一个student匿名结构体即可。
也就是说：在Golang中，如果一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性。
嵌套匿名结构体的基本语法
type Goods struct { Name string Price int } type Book struct{ Goods // 这里就是嵌套匿名结构体Goods Writer string }
继承给编程带来的便利
- 代码的复用性提高了
- 代码的扩展性和维护性提高了
继承的深入讨论
a. 结构体可以使用嵌套匿名结构体所有的字段和方法，即：首字母或者小写字段，方法，都可以使用。
package main import ( "fmt" ) type A struct{ Name string age int } func (a *A) SayOk(){ fmt.Println("A SayOk",a.Name) } func (a *A) hello(){ fmt.Println("A hello",a.Name) } type B struct{ A } func main(){ var b B b.A.Name = "tom" b.A.age = 19 b.A.SayOk() b.A.hello() // 上面的写法可以简化 b.Name = "smith" b.age = 20 b.SayOk() b.hello() }
总结
- 当我们直接通过b访问字段或方法时，其执行流程如下比如 b Name
- 编译器会先看b对应的类型有没有Name，如果有，则直接调用B类型的Name字段
- 如果没有就去看B中嵌入的匿名结构体A有没有声明Name字段，如果有就调用，如果没有就继续寻找。如果都没有就报错
b.可以简化
c.当结构体和匿名函数结构体有相同的字段或者方法时，编译器采用就近访问原则访问，希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分
d. 结构体嵌入两个（或多个）匿名结构体，如果两个匿名结构体有相同的字段和方法（同时结构体本身没有同名的字段和方法），在访问时，就必须明确指定匿名结构体名字，否则编译出错
package main import ( "fmt" ) type A struct{ Name string age int } type B struct{ Name string Score float64 } type C struct{ A B // Name string } func main(){ var c C // 如果c 没有Name字段，而A 和 B有Name，这时就必须通过指定匿名结构体名字来区分 // 所以 c.Name 就会包编译错误 c.A.Name = "tom" fmt.Println("c") }
e. 如果一个struct嵌套了一个有名结构体，这种模式就是组合，如果是组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字
f.嵌套匿名结构体后，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值。
面向对象编程-多重继承
多重继承说明
如一个struct嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方法，从而实现了多继承。
多重继承的细节
- 如嵌入的匿名结构体有相同的字段名或者方法名，则在访问时，需要通过匿名结构体名来区分。
- 为了保证代码的简洁性，建议大家尽量不使用多重继承。
接口
基本介绍
按顺序，我们应该讲解多态，但是在讲解多态前，我们需要讲解接口（interface），因为在Golang中，多态特性主要是通过接口来实现的。
入门
这样的设计需求在Golang编程中也是会大量存在的，我曾经说过，一个程序就是一个世界，在现实世界存在的情况，在其他程序中也会出现。我们用程序来模拟一下前面的应用场景。
package main import ( "fmt" ) // 声明一个接口 type Usb interface{ // 声明了两个没有实现的方法 Start() Stop() } type Phone struct{ } // 让Phone实现Usb接口的方法 func (p Phone) Start(){ fmt.Println("手机开始工作...") } func (p Phone) Stop(){ fmt.Println("手机停止工作...") } // 让相机实现Usb接口的方法 type Camera struct{ } // 让Camera实现Usb接口的方法 func (c Camera) Start(){ fmt.Println("相机开始工作...") } func (c Camera) Stop(){ fmt.Println("相机停止工作...") } // 计算机 type Computer struct{ } // 编写一个方法Working方法，接收一个Usb接口类型变量 // 只要实现了Usb接口，（所谓实现Usb接口，就是指实现了 Usb接口声明所有方法） func (c Computer) Working(usb Usb){ // 通过usb接口变量来调用Start和Stop方法 usb.Start() usb.Stop() } func main(){ // 测试 // 先创建结构体变量 computer := Computer{} phone := Phone{} //camera := Camera{} // 关键点 computer.Working(phone) }
接口（interface）练习题
正常
type Alnterface interface{ Test01() Test02() } type Blnterface interface{ Test01() Test03() } type Stu struct{ } func (stu Stu) Test01(){ } func (stu Stu) Test02(){ } func (stu Stu) Test03(){ } func main(){ stu := Stu{} var a Alnterface = stu var b Blnterface = stu fmt.Println("ok~",a,b) }
问题代码
type Alnterface interface{ Test01() Test02() } type Blnterface interface{ Test01() Test03() } type Clnterface interface{ Alnterface Blnterface } func main(){ } //这里编译器错误，因为Clinterface有两个Test01（），编译器不能通过
package main import "fmt" type Usb interface { Say() } type Stu struct{ } func (this *Stu) Say(){ fmt.Println("Say()") } func main(){ var stu Stu = Stu{} // 错误！ 会报Stu类型没有实现Usb接口， // 如果希望通过编译， var u Usb = &stu var u Usb = stu u.Say() fmt.Println("here", u) }
接口最佳实践
package main import ( "fmt" "sort" "math/rand" ) // 1.声明Hero结构体 type struct Hero{ 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 } 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] } 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切片 append(heroes,hero) } // 看看排序前的顺序 for _,v := range heroes{ fmt.Println(v) } // 调用sort.Sort sort.Sort(heroes) fmt.Println("-------------排序后--------") // 看看排序后的顺序 for _,v := range heroes{ fmt.Println(v) } }
接口&继承
package main import ( "fmt" ) // Monkey 结构体 type Monkey struct{ Name string } func (this *Monkey) climbling(){ fmt.Println(this.Name,"生来会爬树..") } // littleMonkey 结构体 type LittleMonkey struct{ Monkey // 继承 } // 声明接口 type BirdAble interface{ Flying() } // 声明接口 type FishAble interface{ Swimming() } // 让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() }
总结：当一个机构体继承了B结构体，那么A结构体就自动的继承了B结构体的字段和方法，并且可以直接使用
当A结构体需要扩展功能，同事不希望去破坏继承关系，则可以去实现某个接口即可，因此我们可以认为实现接口是对继承机制的补充
- 实现接口可以看做是对继承的一种补充
- 接口和继承解决的问题不同
继承的价值主要在于：解决代码的可维护性和复用性
接口的价值在于：设计，设计好各种规范方法，让其他自定义类型去实现这些方法。 - 接口比继承更加灵活
接口比继承更加灵活，继承是满足is-a的关系，而接口只需满足like-a的关系 - 接口在一定程度上实现代码解耦
多态
介绍
变量（实例）具有多种形态，面向对象的第三大特征，在Go语言中，多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态。
- 多态参数
在前面Usb接口案例，Usb usb,即可以接收手机变量，又可以接收相机变量，就体现了Usb接口多态 - 多态数组
给Usb数组中，存放Phone结构体和Camera结构体变量
类型断言
func main(){ var a interface{} var point Point = Point{1,2} a = point var b Point b = a.(Point) // 类型断言 fmt.Println(b) }
b=a.(Point)就是类型断言，表示判断a是否指向Point类型的变量，如果是就转成Point类型赋值给b变量，否则就报错
介绍
类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言，具体如下：
var x interface{} var b2 float32 = 1.1 x = b2 // 空接口，可以接收任何类型 // x=>float32[使用类型断言] y := x.(float32) fmt.Printf("y 的类型是 %T 值是=%v",y,y)
说明
在进行类型断言时，如果类型不匹配，就会报panic，因此进行类型断言时，要确保原来的空接口指向的就是断言的类型。
如何在进行断言时，带上检测机制，如果成功就OK，否则也不要报panic
// 类型断言（带检测的） var x interface{} var b2 float32 = 2.1 x = b2 // 空接口，可以接收任意类型 // x=>float32[使用类型断言] // 类型断言（带检测的） if y,ok := x.(float32);ok { fmt.Println("convert success") fmt.Printf("y 的类型是 %T 值是=%v",y,y) }else{ fmt.Println("convert fail") } fmt.Println("继续执行...")
感谢大家观看，我们下次见
