第十一章 Golang面向对象编程(下)

简介: 第十一章 Golang面向对象编程(下)

面向对象编程三大特性

基本介绍

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. 可以对数据进行验证,保证安全合理

实现

1.对结构体中的属性进行封装

2. 通过方法,包 实现封装

实现步骤

  1. 将结构体,字段(属性)的首字母小写(不能导出了,其他包不能使用,类似private)
  2. 给结构体所在包提供一个工厂模式的函数,首字母大写,类似一个构造函数
    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())
}

练习

要求:

  1. 创建程序,在model包中定义Account结构体:在main函数中体会Golang的封装性
  2. Account结构体要求具有字段:账号(长队在6-10之间),余额(必须>20),密码(必须是六位)
  3. 通过SetXxx的方法给Account的字段赋值。
  4. 在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
}

继承给编程带来的便利

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

继承的深入讨论

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()
}

总结

  1. 当我们直接通过b访问字段或方法时,其执行流程如下比如 b Name
  2. 编译器会先看b对应的类型有没有Name,如果有,则直接调用B类型的Name字段
  3. 如果没有就去看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嵌套了多个匿名结构体,那么该结构体可以直接访问嵌套的匿名结构体的字段和方法,从而实现了多继承。

多重继承的细节

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

接口

基本介绍

按顺序,我们应该讲解多态,但是在讲解多态前,我们需要讲解接口(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结构体需要扩展功能,同事不希望去破坏继承关系,则可以去实现某个接口即可,因此我们可以认为实现接口是对继承机制的补充

  1. 实现接口可以看做是对继承的一种补充
  2. 接口和继承解决的问题不同
    继承的价值主要在于:解决代码的可维护性和复用性
    接口的价值在于:设计,设计好各种规范方法,让其他自定义类型去实现这些方法。
  3. 接口比继承更加灵活
    接口比继承更加灵活,继承是满足is-a的关系,而接口只需满足like-a的关系
  4. 接口在一定程度上实现代码解耦

多态

介绍

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

  1. 多态参数
    在前面Usb接口案例,Usb usb,即可以接收手机变量,又可以接收相机变量,就体现了Usb接口多态
  2. 多态数组
    给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("继续执行...")

感谢大家观看,我们下次见

目录
相关文章
|
安全 Go
Golang 语言是面向对象编程风格的编程语言吗?
Golang 语言是面向对象编程风格的编程语言吗?
47 0
|
2月前
|
Go
Golang语言结构体(struct)面向对象编程进阶篇(封装,继承和多态)
这篇文章是关于Go语言中结构体(struct)面向对象编程进阶篇的教程,涵盖了Go语言如何实现封装、继承和多态,以及结构体内存布局的相关概念和案例。
126 4
|
2月前
|
Go
Golang语言结构体(struct)面向对象编程基础篇
这篇文章是关于Go语言中结构体(struct)面向对象编程的基础教程,详细介绍了面向对象编程在Go语言中的应用、结构体的定义与初始化、方法定义、跨包实例化结构体以及结构体方法和普通函数的区别。
31 4
|
6月前
|
Go 开发者
Golang深入浅出之-Go语言方法与接收者:面向对象编程初探
【4月更文挑战第22天】Go语言无类和继承,但通过方法与接收者实现OOP。方法是带有接收者的特殊函数,接收者决定方法可作用于哪些类型。值接收者不会改变原始值,指针接收者则会。每个类型有相关方法集,满足接口所有方法即实现该接口。理解并正确使用这些概念能避免常见问题,写出高效代码。Go的OOP机制虽不同于传统,但具有灵活性和实用性。
49 1
|
6月前
|
程序员 Go
第十章 Golang面向对象编程(上)
第十章 Golang面向对象编程(上)
56 2
Golang面向对象编程之构造函数【struct&new】
Golang面向对象编程之构造函数【struct&new】
Golang面向对象编程之继承&虚基类【组合&接口】
Golang面向对象编程之继承&虚基类【组合&接口】
|
缓存 安全 Java
Golang 面向对象编程
Golang 面向对象编程
81 0
|
2月前
|
Go
Golang语言之管道channel快速入门篇
这篇文章是关于Go语言中管道(channel)的快速入门教程,涵盖了管道的基本使用、有缓冲和无缓冲管道的区别、管道的关闭、遍历、协程和管道的协同工作、单向通道的使用以及select多路复用的详细案例和解释。
98 4
Golang语言之管道channel快速入门篇
|
2月前
|
Go
Golang语言文件操作快速入门篇
这篇文章是关于Go语言文件操作快速入门的教程,涵盖了文件的读取、写入、复制操作以及使用标准库中的ioutil、bufio、os等包进行文件操作的详细案例。
62 4
Golang语言文件操作快速入门篇