golang面向对象编程思想

一、抽象

就是把一类事物的共有属性(字段)和行为(方法)提取出来,形成一个物理模板。这种研究问题的方法称为抽象。

例子:
银行账号都有卡号,密码和余额属性,且可以存款,取款,查询余额这些行为,我们将这些属性和行为提取出来,形成一个模板,用代码实现如下:
项目结构图:
image

account.go

package model

import "fmt"

// 银行账号
type Account struct {
	AccountNo string  // 卡号
	Pwd       string  // 密码
	Balance   float64 // 余额
}

// 存款
func (account *Account) Deposite(money float64, pwd string) {
	// 检验密码
	if account.Pwd != pwd {
		fmt.Println("密码不正确")
		return
	}

	// 检验存款金额
	if money < 0 {
		fmt.Println("输入的金额不正确")
		return
	}
	account.Balance = account.Balance + money
	fmt.Println("存款成功")
}

// 取款
func (account *Account) WithDraw(money float64, pwd string) {
	// 检验密码
	if account.Pwd != pwd {
		fmt.Println("密码不正确")
		return
	}
	// 检验取款金额
	if money < 0 || money > account.Balance {
		fmt.Println("输入的金额不正确")
		return
	}
	account.Balance = account.Balance - money
	fmt.Println("取款成功")
}

// 查询余额
func (account *Account) Query(pwd string) {
	// 检验密码
	if account.Pwd != pwd {
		fmt.Println("密码不正确")
		return
	}
	fmt.Printf("你的账号%v余额为%v\n", account.AccountNo, account.Balance)
}

main.go

package main

import (
	"model"
)

func main() {
	account := model.Account{
		AccountNo: "pf11111111",
		Pwd:       "666666",
		Balance:   1000,
	}
	// 查询余额
	account.Query("666666")
	// 存款
	account.Deposite(1000, "666666")
	// 查询余额
	account.Query("666666")
	// 取款
	account.WithDraw(200, "666666")
	// 查询余额
	account.Query("666666")
	// 查询余额
	account.Query("888888")
}

输出结果:

你的账号pf11111111余额为1000
存款成功
你的账号pf11111111余额为2000
取款成功
你的账号pf11111111余额为1800
密码不正确

二、 封装

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

1. 实现封装的步骤
  • 将结构体、字段(属性)的首字母小写(不能导出,其他包不能使用,类似private)
  • 给结构体所在的包提供一个工厂模式的函数,首字母大写,类似一个构造函数
  • 提供一个首字母大写的Set方法,用于对属性判断并赋值
  • 提供一个首字母大写的Get方法用于获取属性的值

例子:
一个人的年龄和工资是属于隐私信息,我们如何实现封装,代码如下:
项目结构图:
image
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 > 0 {
		p.sal = sal
	} else {
		fmt.Println("薪水范围不正确")
	}
}

func (p *person) GetSal() float64 {
	return p.sal
}

main.go

package main

import (
	"fmt"
	"model"
)

func main() {
	p := model.NewPerson("小王")
	fmt.Println("p=", *p)
	p.SetAge(20)
	p.SetSal(5000)
	fmt.Printf("%v年龄是%v,薪水是%v\n", p.Name, p.GetAge(), p.GetSal())
}

输出结果:

p= {小王 0 0}
小王年龄是20,薪水是5000

三、继承

当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体,在该结构体中定义这些相同的属性和方法。其他结构体不需要重新定义这些属性和方法,只需嵌套该结构体的匿名结构体即可。也就是说在Golang中,如果一个struct嵌套了另一个结构体,那么这个结构体可以直接访问匿名结构体的字段和方法,从而实现了继承特性
例子:
编写一个学生考试系统
项目结构图:
image
student.go

package model

import "fmt"

type Student struct {
	Name  string
	Age   int
	Score float32
}

func (stu *Student) ShowInfo() {
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n", stu.Name, stu.Age, stu.Score)
}

func (stu *Student) SetScore(score float32) {
	stu.Score = score
}

pupil.go

package model

import "fmt"

// 小学生
type Pupil struct {
	Student // 嵌入Student匿名结构体,实现继承
}

func (pupil Pupil) Testing() {
	fmt.Println("小学生正在考试中...")
}

graduate.go

package model

import "fmt"

// 大学生
type Graduate struct {
	Student // 嵌入Student匿名结构体,实现继承
}

func (graduate Graduate) Testing() {
	fmt.Println("大学生正在考试中...")
}

main.go

package main

import (
	"model"
)

func main() {
	pupil := model.Pupil{}
	pupil.Name = "tom"
	pupil.Age = 10
	pupil.Testing()
	pupil.SetScore(80)
	pupil.ShowInfo()

	graduate := model.Graduate{}
	graduate.Name = "mary"
	graduate.Age = 20
	graduate.Testing()
	graduate.SetScore(100)
	graduate.ShowInfo()
}

输出结果:

小学生正在考试中...
学生名=tom 年龄=10 成绩=80
大学生正在考试中...
学生名=mary 年龄=20 成绩=100
1.细节
  • 当结构体和匿名结构体有相同的字段或者方法时,编译器采用就近访问原则,如希望访问匿名结构体的字段和方法,可以通过匿名结构体名来区分。
package main

import (
	"fmt"
)

type A struct {
	Name string
}

func (a *A) SayHello() {
	fmt.Println("A.......SayHello", a.Name)
}

type B struct {
	A
	Name string
}

func (b *B) SayHello() {
	fmt.Println("B.......SayHello", b.Name)
}

func main() {
	b := B{}
	b.Name = "tom"
	b.SayHello()
	b.A.SayHello()
	b.A.Name = "marry"
	b.A.SayHello()
}

输出结果:

B.......SayHello tom
A.......SayHello 
A.......SayHello marry
  • 结构体嵌入两个(或多个)匿名结构体,若两个结构体有相同的字段和方法(同时结构体本身没有同名的字段和方法),在访问时,就必须明确指定匿名结构体名字,否则编译报错
package main

import (
	"fmt"
)

type A struct {
	Name string
	Age  int
}
type B struct {
	Name  string
	Score float32
}

func (a *A) SayHello() {
	fmt.Println("A.......SayHello", a.Name)
}

func (b *B) SayHello() {
	fmt.Println("B.......SayHello", b.Name)
}

type C struct {
	A
	B
}

func main() {
	var c C
	// 如果C没有Name字段,而A和B有Name字段,这时就必须通过指定匿名结构体名字区分
	// 所以c.Name就会编译错误,这个规则对方法也是一样的
	// c.Name = "tom" // 编译报错
	c.A.Name = "tom"
	c.Age = 10
	c.B.Name = "jack"
	c.Score = 88.8
	// c.SayHello() // 编译报错
	fmt.Println("c=", c)
	c.A.SayHello()
	c.B.SayHello()
}

输出结果:

c= {{tom 10} {jack 88.8}}
A.......SayHello tom
B.......SayHello jack
  • 如果一个结构体嵌套了一个有名结构体,这种模式是组合,如果是组合关系,那么在访问组合结构体的字段或方法时,必须带上结构体名字的
package main

import (
	"fmt"
)

type A struct {
	Name string
	Age  int
}
type B struct {
	a A // 组合关系
}

func (a *A) SayHello() {
	fmt.Println("A.......SayHello", a.Name)
}

func main() {
	var b B
	// 如果一个结构体嵌套了一个有名结构体,这种模式是组合,如果是组合关系,
	// 那么在访问组合结构体的字段或方法时,必须带上结构体名字的
	b.a.Name = "tom"
	b.a.Age = 10
	fmt.Println("b=", b)
	b.a.SayHello()
}

输出结果:

b= {{tom 10}}
A.......SayHello tom
  • 嵌套匿名结构体后,也可以在创建结构体变量(实例时),直接指定各个匿名结构体字段的值
package main

import (
	"fmt"
)

type Goods struct {
	Name  string
	Price float64
}
type Brand struct {
	Name    string
	Address string
}
type TV struct {
	Goods
	Brand
}

func main() {
	tv1 := TV{Goods{"电视机001", 6000.89}, Brand{"海尔", "山东"}}
	// 嵌套匿名结构体后,也可以在创建结构体变量(实例时),直接指定各个匿名结构体字段的值
	tv2 := TV{
		Goods{
			Name:  "电视机002",
			Price: 8000.89,
		},
		Brand{
			Name:    "康佳",
			Address: "青岛",
		},
	}
	fmt.Println("tv1=", tv1)
	fmt.Println("tv2=", tv2)
}

输出结果:
tv1= {{电视机001 6000.89} {海尔 山东}}
tv2= {{电视机002 8000.89} {康佳 青岛}}

posted @ 2021-05-27 23:01  若雨蚂蚱  阅读(109)  评论(0编辑  收藏  举报