Posted 2019ab
tags: .net 2.0面向对象编程揭秘 .net 4.0面向对象编程漫谈 .net 面向对象编程 .net面向对象编程 .net面向对象编程教程
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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. 通过方法，包 实现封装
实现步骤
- 将结构体，字段（属性）的首字母小写（不能导出了，其他包不能使用，类似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)
215
感谢大家观看，我们下次见
以上是关于Golang面向对象编程（下）的主要内容，如果未能解决你的问题，请参考以下文章