golang面向对象下

1、面向对象编程思想——抽象

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

代码实现

package main

import "fmt"

//定义一个结构体Account
type Account struct {
	AccountNo string
	Pwd       string
	Balance   float64
}

//存款
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.Println("你的账号为=%v 余额=%v \n", account.AccountNo, account.Balance)
}

func main() {
	account := Account{
		AccountNo: "622848",
		Pwd:       "666666",
		Balance:   10000,
	}
	account.Query("666666")
	account.Deposite(250.0, "666666")
	account.Query("666666")
	account.WithDraw(150.0, "666666")
	account.Query("666666")
}

2、面向对象编程三大特性——封装

（1）基本介绍
Golang仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其它OOP语言不一样。
（2）封装介绍
封装(encapsulation)就是把抽象出的字段和对字段的操作封装在一起，数据被保护在内部，程序的其它包只有通过被授权的操作(方法)，才能对字段进行操作。
（3）封装的好处
1）隐藏实现细节
2）可以对数据进行验证，保证安全合理
（4）golang如何体现封装
1）对结构体中的属性进行封装
2）通过方法，包实现封装
（5）封装的实现步骤

1. 将结构体、字段(属性)的首字母小写(不能导出了，其它包不能使用，类似private)
   2)给结构体所在包提供一个工厂模式的函数，首字母大写。类似-一个构造函数
   3)提供一个首字母大写的Set方法(类似其它语言的public)，用于对属性判断并赋值
   func (var结构体类型 名) SetXxx(参数列表) (返回值列表) {
   //加入数据验证的业务逻辑
   var.字段=参数
   }
   4)提供一个首字母大写的Get方法(类似其它语言的public)，用于获取属性的值
    func (var 结构体类型名) GetXxx() {
    return var.age;
    }
   （6）入门案例
     请大家看一个程序(person.go),不能随便查看人的年龄,工资等隐私，并对输入的年龄进行合理的验证。设计: model包(person.go) main包(main.go调用Person结构体)
   代码实现
   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和SetXXX方法
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

package main

import (
	"fmt"
	model "person"
)

func main() {
	p := model.NewPerson("tom")
	p.SetAge(19)
	p.SetSal(5000)
	fmt.Println(p)
	fmt.Println(p.Name, "age=", p.GetAge(), "sal=", p.GetSal())
}

案例2
➢要求

1. 创建程序,在model包中定义Account结构体:在main函数中体会Golang的封装性。
2. Account 结构体要求具有字段:账号(长度在6-10之间)、余额(必须>20)、密码(必须是六位数）
   3)通过SetXxx的方法给Account的字段赋值。
   4)在main函数中测试
   代码实现
   account.go

package model

import "fmt"

//定义一个account结构体
type account struct {
	accountNo string
	pwd       string
	balance   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,
	}
}

//存款
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)
}
//Set和Get方法
func (a *account) SetAccountNo(accountNo string) {
	if len(accountNo) > 6 && len(accountNo) < 10 {
		a.accountNo = accountNo
	} else {
		fmt.Println("账号长度不正确")
	}
}
func (a *account) GetaccountNo() string {
	return a.accountNo
}
func (a *account) SetPwd(pwd string) {
	if len(pwd) == 6 {
		a.pwd = pwd
	} else {
		fmt.Println("密码长度不正确")
	}
}
func (a *account) GetPwd() string {
	return a.pwd
}
func (a *account) SetBalance(balance float64) {
	if balance > 10 {
		a.balance = balance
	} else {
		fmt.Println("余额数目不正确")
	}
}
func (a *account) GetBalance() float64 {
	return a.balance
}

main.go

package main

import (
	"fmt"
	model "person"
)

func main() {
	
	//创建一个account变量
	account := model.NewAccount("dry11111", "666666", 100)
	if account != nil {
		fmt.Printf("创建成功=", account)
	} else {
		fmt.Println("创建失败")
	}
	account.SetAccountNo("123456")
	account.SetPwd("666666")
	account.SetBalance(1000)
	fmt.Println("账号=", account.GetaccountNo(), "密码=", account.GetPwd(), "余额=", account.GetBalance())
}