Golang面向对象编程(下)

Posted 2019ab

tags: .net 2.0面向对象编程揭秘    .net 4.0面向对象编程漫谈    .net 面向对象编程    .net面向对象编程    .net面向对象编程教程   

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Golang面向对象编程(下)相关的知识,希望对你有一定的参考价值。

面向对象编程三大特性

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

封装

面向对象编程思想-抽象

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

package main

import (
	"fmt"
)

// 定义一个结构体
type Account struct
	AccountNo string
	Pwd string
	Banlance float64


// 方法
// 1.存款
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)


func main()
	//  测试
	account := Account
		AccountNo:"gs111",
		Pwd:"666666",
		Balance:100.0
	
	account.Query("666666")
	account.Deposite(200.0,"666666")
	account.Query("666666")
	account.Withdraw(20.0,"666666")
	account.Query("666666")

封装介绍

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

优点

  1. 隐藏实现细节
  2. 可以对数据进行验证,保证安全合理

实现
1.对结构体中的属性进行封装
2. 通过方法,包 实现封装

实现步骤

  1. 将结构体,字段(属性)的首字母小写(不能导出了,其他包不能使用,类似private)
  2. 给结构体所在包提供一个工厂模式的函数,首字母大写,类似一个构造函数
    3 . 提供一个首字母大写的Set方法类似其他语言的public,用于对属性判断并赋值
func (var 结构体类型名)SetXxx(参数列表)(返回值列表)
   // 加入数据验证的业务逻辑
   var 字段 = 参数

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

func (var 结构体类型名) GetXxx()
   return var.age;


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

案例

// 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 >= 3000 && sal <= 30000
		p.sal = sal
   else
		fmt.Println("薪水范围不正确..")
	


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

// main.go
import (
	"fmt"
	"go_code/chapter11/encapsulate/model"
)
func main()
   p := model.NewPerson("smith")
   p.SetAge(18)
   p.SetSal(5000)
   fmt.Println(p)
   fmt.Println(p.Name,"age =",p.GetAge(),"sal = ",p.GetSal())

练习
要求:

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

import (
	"fmt"
)

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

// 方法
// 1.存款
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)


package main

import (
	"fmt"
	"go_code/chapter11/encapexercise/model"
)

func main()
  // 创建一个account变量
  account := model.NewAccount("jzh111111","999999",40)
  if account != nil
		fmt.Println("创建成功=",account)
   else
		fmt.Println("创建失败")
	

继承
继承可以解决代码复用,让我们的编程更加靠近人类思维。

当多个结构体存在相同的属性(字段)和方法,只需嵌入一个student匿名结构体即可。

也就是说:在Golang中,如果一个struct嵌套了另一个匿名结构体,那么这个结构体可以直接访问匿名结构体的字段和方法,从而实现了继承特性。

嵌套匿名结构体的基本语法

type Goods struct 
   Name string
   Price int


type Book struct
   Goods // 这里就是嵌套匿名结构体Goods
   Writer string

继承给编程带来的便利

  1. 代码的复用性提高了
  2. 代码的扩展性和维护性提高了

继承的深入讨论

a. 结构体可以使用嵌套匿名结构体所有的字段和方法,即:首字母或者小写字段,方法,都可以使用。

package main
import (
	"fmt"
)

type A struct
  Name string
  age int


func (a *A) SayOk()
	fmt.Println("A SayOk",a.Name)


func (a *A) hello()
  fmt.Println("A hello",a.Name)


type B struct
	A


func main()
  var b B
  b.A.Name = "tom"
  b.A.age = 19
  b.A.SayOk()
  b.A.hello()
  // 上面的写法可以简化
  b.Name = "smith"
  b.age = 20
  b.SayOk()
  b.hello()

总结

  1. 当我们直接通过b访问字段或方法时,其执行流程如下比如 b Name
  2. 编译器会先看b对应的类型有没有Name,如果有,则直接调用B类型的Name字段
  3. 如果没有就去看B中嵌入的匿名结构体A有没有声明Name字段,如果有就调用,如果没有就继续寻找。如果都没有就报错

b.可以简化
c.当结构体和匿名函数结构体有相同的字段或者方法时,编译器采用就近访问原则访问,希望访问匿名结构体的字段和方法,可以通过匿名结构体名来区分
d. 结构体嵌入两个(或多个)匿名结构体,如果两个匿名结构体有相同的字段和方法(同时结构体本身没有同名的字段和方法),在访问时,就必须明确指定匿名结构体名字,否则编译出错

package main
import (
	"fmt"
)

type A struct
  Name string
  age int

type B struct
  Name string
  Score float64

type C struct
  A
  B
  // Name string


func main()
  var c C
  // 如果c 没有Name字段,而A 和 B有Name,这时就必须通过指定匿名结构体名字来区分
  // 所以  c.Name 就会包编译错误
  c.A.Name = "tom"
  fmt.Println("c")

e. 如果一个struct嵌套了一个有名结构体,这种模式就是组合,如果是组合关系,那么在访问组合的结构体的字段或方法时,必须带上结构体的名字

f.嵌套匿名结构体后,也可以在创建结构体变量(实例)时,直接指定各个匿名结构体字段的值。

面向对象编程-多重继承

多重继承说明
如一个struct嵌套了多个匿名结构体,那么该结构体可以直接访问嵌套的匿名结构体的字段和方法,从而实现了多继承。

多重继承的细节

  1. 如嵌入的匿名结构体有相同的字段名或者方法名,则在访问时,需要通过匿名结构体名来区分。
  2. 为了保证代码的简洁性,建议大家尽量不使用多重继承。

接口

基本介绍
按顺序,我们应该讲解多态,但是在讲解多态前,我们需要讲解接口(interface),因为在Golang中,多态特性主要是通过接口来实现的。

入门
这样的设计需求在Golang编程中也是会大量存在的,我曾经说过,一个程序就是一个世界,在现实世界存在的情况,在其他程序中也会出现。我们用程序来模拟一下前面的应用场景。

package main
import (
 "fmt"
)
// 声明一个接口
type Usb interface
  // 声明了两个没有实现的方法
  Start()
  Stop()


type Phone struct


// 让Phone实现Usb接口的方法
func (p Phone) Start()
  fmt.Println("手机开始工作...")

func (p Phone) Stop()
  fmt.Println("手机停止工作...")


// 让相机实现Usb接口的方法
type Camera struct


// 让Camera实现Usb接口的方法
func (c Camera) Start()
  fmt.Println("相机开始工作...")

func (c Camera) Stop()
  fmt.Println("相机停止工作...")

// 计算机
type Computer struct
 

// 编写一个方法Working方法,接收一个Usb接口类型变量
// 只要实现了Usb接口,(所谓实现Usb接口,就是指实现了 Usb接口声明所有方法)
func (c Computer) Working(usb Usb)
  // 通过usb接口变量来调用Start和Stop方法
  usb.Start()
  usb.Stop()

func main()
   // 测试
   // 先创建结构体变量
   computer := Computer
   phone := Phone
   //camera := Camera
 
   // 关键点
   computer.Working(phone)
   


215

感谢大家观看,我们下次见

以上是关于Golang面向对象编程(下)的主要内容,如果未能解决你的问题,请参考以下文章