1.面向对象编程思想-抽象

抽象的介绍:

        前面章节讲解了在定义一个结构体的时候,实际上就是把一类事物的共有的属性(字段)和行为(方法)提取出来,形成一个物理模型(结构体),这种研究问题的方法称为抽象,如下图所示:

 

package main
 
import(
    "fmt"
)
 
type  Account struct{
    AccountNo string
    Pwd string
    Balance float64
}
//方法
//1.存款
func (account *Account) Deposite(money float64, pwd string) {
    //判断密码
    if pwd != account.Pwd {
        fmt.Println("密码错误")
        return
    }
    //判断金额
    if money <= 0 {
        fmt.Println("金额有误")
    }
    //增加存款
    account.Balance += money
    fmt.Println("存钱成功")
}
//2.取款
func (account *Account) Withdraw(money float64, pwd string) {
    //判断密码
    if pwd != account.Pwd {
        fmt.Println("密码错误")
        return
    }
    //判断取款金额
    if money <= 0 || money > account.Balance {
        fmt.Println("金额有误")
    }
    //减少存款
    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:"建设银行100011",
        Pwd: "123456",
        Balance: 100,
    }
    account.Query("123456")
}

 2.基本介绍

go语言仍然有面向对象编程的继承,封装,和多态的特性,只是实现的方式和其它OOP语言不一样.

封装的介绍:

        封装就是把抽象出来的字段和对字段的操作封装在一起,数据被保护在内部,程序的其他包只有通过被授权的操作(方法),才能对字段进行操作

        这样做的好处:

                (1).隐藏实现的细节

                (2).可以对数据进行验证,保证数据的安全合理

3.如何体现封装

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

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

4.封装的实现步骤

(1) .将结构体,字段(属性)的首字母小写(不能导出了,其他包不能使用,类似private)

(2).给结构体所在的包提供一个工厂模式的函数,首字母大写,类似一个构造函数

(3).提供一个首字母大写的Set方法(类似其他语言的public),用于对属性判断并赋值

func (var 结构体类型名) SetXxx(参数列表) (返回值列表) {

         //加入数据验证的业务逻辑

         var 字段 = 参数

}

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

func (var 结构体类型名) GetXxx(参数列表) (返回值列表) {

        return var.属性

}

特别说明:

        在go语言中没有特别强调封装,这点不像java,所以不用总是用java语言语法特性来看待go,go本身对面向对象做了简化的

5.案例

写一个程序(Person.go),不能随便看人的年龄,工资等,并对输入的年龄进行合理的验证. 

model包 

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 < 100 {
        p.age = age
    } else {
        fmt.Println("年龄不正确")
        //可以给一个默认值
    }
}
 
func (p *person) GetAge() int {
    return p.age
}
//为了访问age和sal,写一对Setxxx,Getxxx方法
func (p *person) SetSal(sal float64) {
    if sal > 3000 && sal < 100000 {
        p.sal = sal
    } else {
        fmt.Println("薪水不正确")
        //可以给一个默认值
    }
}
 
func (p *person) GetSal() float64 {
    return p.sal
}

 main包

package main
 
import(
    "fmt"
    "go_code/chapter11/exersice/model"
)
 
func main() {
    p := model.NewPerson("Jack")
    // p.age = 11 //错误
    p.SetAge(11) //正确
    
    fmt.Println(p) //&{Jack 0 0}
    fmt.Println("年龄:", p.GetAge())//年龄: 11
}

[上一节][go学习笔记.第十章.面向对象编程] 7.工厂模式

[下一节][go学习笔记.第十章.面向对象编程] 9.面向对象的三大特性-继承