Go---工厂模式，封装

工厂模式
Golang的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。

工厂模式来解决问题
使用工厂模式实现跨包创建结构体实例(变量)的案例: 
1) 如果model 包的结构体变量首字母大写， 引入后，直接使用，没有问题.

 main.go

package main

import (

    "fmt"

    "secondGo/factory/model"

)

func main(){

var stu = model.Student{

    Name: " kegld",

    Score : 69.6,

}

fmt.Println(stu)

}

student.go

package model

//定义一个结构体

type Student struct{

    Name string

    Score float64

}

2) 如果model包的结构体变量首字母小写，引入后，不能直接使用,可以工厂模式解决

student.go

package model

//定义一个结构体

type student struct{

    Name string

    Score float64

}

//因为student结构体首字母是小写，因此是只能在mode1使用

//我们通过工厂模式来解决

func NewStudent(n string,s float64) *student{

    return &student{

        Name : n ,

        Score : s ,

    }

}

main.go

package main

import (

    "fmt"

    "secondGo/factory/model"

)

func main(){

// var stu = model.Student{

//  Name: " kegld",

//  Score : 69.6,

// }

//定student结构体是首字母小写，我们可以通过工厂模式来解决

var stu = model.NewStudent("heyhey",66.6)

fmt.Println(stu)

}

访问首字母小写的字段 student.go

package model

//定义一个结构体

type student struct{

    Name string

    score float64

}

//因为student结构体首字母是小写，因此是只能在mode1使用

//我们通过工厂模式来解决

func NewStudent(n string,s float64) *student{

    return &student{

        Name : n ,

        score : s ,

    }

}

//如果score字段首字母小写，则，在其它包不可以直接方法，我们可以提供一个方法

func (s *student) GetScore() float64{

    return s.score //ok

}

面问对象编程思想----抽象
如何理解抽象
    我们在前面去定义一个结构体时候，实际上就是把一类事物的共有的属性和行为提取出来形成一个物理模型(模板)。这种研究问题的方法称为抽象。

面向对象编程三大特性

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

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

封装的理解和好处
1) 隐藏实现细节
2) 可以对数据进行验证，保证安全合理
如何体现封装
1) 对结构体中的属性进行封装
2) 通过方法，包 实现封装

封装的实现步骤
1) 将结构体、字段(属性)的首字母小写(不能导出了，其它包不能使用，类似private）
2)  给结构体所在包提供 一个工厂模式的函数，首字母大写。类似一个构造函数
3) 提供一个首字母大写的Set方法(类 似其它语言的public),用于对属性判断并赋值
func (var结构体类型名) Setxx(参数列表) (返回值列表) {
//加入数据验证的业务逻辑
var:字段=参数
}
4) 提供一个首字母大写的Get方法(类似其它语言的public)，用于获取属性的值
func (var结构体类型名) Gexxx() {
return var.字段

}
特别说明:在Golang开发中并没有特别强调封装，这点并不像Java.所以提醒学过java的朋友，不用总是用java的语法特性来看待Golang, Golang本身对面向对象的特性做了简化的。

for example

person.go

package model

import (

    "fmt"

)

type person struct {

    Name string

    age int //首字母小写不能直接访问

    sal float64

}

//写一个函数，

func NewPerson(name string) *person{

    return &person{

        Name : name,

    }

}

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) GetSal()float64{

    return p.sal

}

func (p *person) SetSal(sal float64){

    if sal >3000 && sal <1500000{

        p.sal= sal

    }else{

        fmt.Println("薪水范围不正确")

        //设置一个默认值

    }

}

main.go

package main

import (

    "fmt"

    "secondGo/encanple/model"

)

func main(){

    p := model.NewPerson("hihi")

    p.SetAge(18)

    p.SetSal(5000)

    fmt.Println(p)

    fmt.Println("姓名",p.Name,"年龄",p.GetAge(),"薪资",p.GetSal())

}

for example  封装实例

 account.go

package  model

import (

    "fmt"

)

//定义一个结构体account

type account struct {

    accountNum string

    pwd string

    balance float64

}

//工厂模式的函数----》构造函数

func NewAccount(accountNum string ,pwd string,balance float64) *account{

    if len(accountNum) <6 || len(accountNum) > 10 {

        fmt.Println("账号的长度不对。。。")

        return nil

    }

    if len(pwd) != 6  {

        fmt.Println("密码的长度不对。。。")

        return nil

    }

    if balance < 0  {

        fmt.Println("余额的资金不对。。。")

        return nil

    }

    //返回一个 结构体account 类型

    return &account{

        accountNum : accountNum,

        pwd : pwd,

        balance : balance,

    }

}

 

func (a *account) SetAccountNum(accountNum string){

        a.accountNum = accountNum

}

func (a *account) GetAccountNum() string {

    return a.accountNum

}

func (a *account) SetPwd(Pwd string){

    a.pwd = Pwd

}

func (a *account) GetPwd() string {

return a.pwd

}

func (a *account) SetBalance(Balance float64){

    a.balance = Balance

}

func (a *account) GetBalance() float64 {

return a.balance

}

main.go

package main

import (

    "fmt"

    "secondGo/count/model"

)

func main(){

    //创建一个account

    account := model.NewAccount("ok12345","893632",63)

    if account != nil {

        fmt.Println("创建成功=",account)

    }else {

        fmt.Println("创建失败")

    }

    account.SetAccountNum("666666")

    fmt.Println(account.GetAccountNum())

    fmt.Println(account.GetBalance())

    fmt.Println(account.GetPwd())

}