介绍

封装（encapsulation）就是把抽象出来的字段和对字段的操作封装在一起，数据被保护在内部，程序的其它包只有通过被授权的操作（方法），才能对字段进行操作。
栗子： 对电视机的操作就是典型的封装。

好处

  1. 隐藏实现的细节

  2. 可以对数据进行验证，保证安全合理

    怎么实现封装

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

  4. 通过方法、包实现封装

    封装实现步骤

  5. 将结构体、字段（属性）的首字母小写（不能导出，私有private）

  6. 给结构体所在的包提供一个工厂模式的函数，首字母大写。（类似一个构造函数）

  7. 提供一个首字母大写的 Set 方法（公开public），用于对属性判断并赋值

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

  8. 提供一个首字母大写的 Get 方法（公开public），用于获取属性的值

    1. func (var 结构体类型名) GetXxx(参数列表) (返回值列表) {
    2.  return var.字段
    3. }

    代码

    对于nil，一般通常指针类型和interface类型可以使用这样的返回值
    go_code/struct/encapsulation/main/main.go ```go package main

import ( “fmt” “go_code/struct/encapsulation/model” )

func main() { p := model.NewPerson(“tom”) // p.age = 18 // p.age undefined (cannot refer to unexported field or method age) p.SetAge(18) p.SetSal(20000) fmt.Println(“p = “, p) fmt.Println(“p.Name = “, p.Name) fmt.Println(“p.age = “, p.GetAge()) fmt.Println(“p.sal = “, p.GetSal()) }

  1. go_code/struct/encapsulation/model/person.go
  2. ```go
  3. // 该程序展示封装
  4. package model
  6. import "fmt"
  8. type person struct {
  9.     Name string
  10.     // 以下字段不公开
  11.     age int
  12.     sal float64
  13. }
  15. // 工厂模式函数，让未公开的标识符可以被外部访问
  16. func NewPerson(name string) *person {
  17.     return &person{
  18.         Name: name,
  19.     }
  20. }
  22. // 为了访问 age 和 sal 我们编写一堆 SetXxx、GetXxx方法
  23. func (p *person) SetAge(age int) {
  24.     // 数据校验
  25.     if age > 0 && age < 150 {
  26.         p.age = age
  27.     } else {
  28.         fmt.Printf("年龄%v不合适", age)
  29.     }
  30. }
  31. func (p *person) GetAge() int {
  32.     return p.age
  33. }
  35. func (p *person) SetSal(sal float64) {
  36.     // 数据校验
  37.     if sal > 3000 && sal < 80000 {
  38.         p.sal = sal
  39.     } else {
  40.         fmt.Printf("薪水%v不合适", sal)
  41.     }
  42. }
  43. func (p *person) GetSal() float64 {
  44.     return p.sal
  45. }

账户封装改造

go_code/struct/encapsulation02/main/main.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "go_code/struct/encapsulation02/model"
  6. )
  8. func main() {
  9.     account := model.NewAccount("js123456", "888888", 22)
  10.     if account != nil {
  11.         fmt.Println("账户创建成功")
  12.     } else {
  13.         fmt.Println("账户创建失败")
  14.     }
  15.     fmt.Println("account = ", account)
  16. }

go_code/struct/encapsulation02/model/account.go

  1. package model
  3. import "fmt"
  5. // 定义一个 account 结构体
  6. type account struct {
  7.     accountNo string
  8.     pwd       string
  9.     blance    float64
  10. }
  12. // 工厂模式的构造函数
  13. func NewAccount(accountNo string, pwd string, blance float64) *account {
  14.     // 数据校验
  15.     if len(accountNo) < 6 || len(accountNo) > 10 {
  16.         fmt.Println("账号长度不对")
  17.         // 对于nil，一般通常指针类型和interface类型可以使用这样的返回值
  18.         return nil
  19.     }
  20.     if len(pwd) != 6 {
  21.         fmt.Println("密码长度不对")
  22.         return nil
  23.     }
  24.     if blance < 20 {
  25.         fmt.Println("余额不对")
  26.         return nil
  27.     }
  28.     return &account{
  29.         accountNo: accountNo,
  30.         pwd:       pwd,
  31.         blance:    blance,
  32.     }
  33. }
  35. // 绑定方法
  36. // 1. 存款
  37. func (account *account) Deposite(money float64, pwd string) {
  38.     // 判断输入的密码是否正确
  39.     if pwd != account.pwd {
  40.         fmt.Println("您输入的密码不正确")
  41.         return
  42.     }
  43.     // 校验金额
  44.     if money < 0 {
  45.         fmt.Println("金额不正确")
  46.         return
  47.     }
  48.     account.blance += money
  49.     fmt.Printf("存款成功，交易后余额： %v \n", account.blance)
  50. }
  52. // 2.取款
  53. func (account *account) WithDraw(money float64, pwd string) {
  54.     // 判断输入的密码是否正确
  55.     if pwd != account.pwd {
  56.         fmt.Println("您输入的密码不正确")
  57.         return
  58.     }
  59.     // 校验金额
  60.     if money < 0 || money > account.blance {
  61.         fmt.Println("金额不正确")
  62.         return
  63.     }
  64.     account.blance -= money
  65.     fmt.Printf("取款成功，交易后余额： %v \n", account.blance)
  66. }
  68. // 2.查询余额
  69. func (account *account) Query(pwd string) {
  70.     // 判断输入的密码是否正确
  71.     if pwd != account.pwd {
  72.         fmt.Println("您输入的密码不正确")
  73.         return
  74.     }
  75.     fmt.Printf("你的账号：%v, 余额： %v \n", account.accountNo, account.blance)
  76. }