正文 

当前位置： 首页 > 程序 > java教程

go语言学习之路(代码片段)

果子哥丶 果子哥丶     2022-12-08     219

关键词：

Go语言学习之路（二）

面对对象编程思想

抽象

  • 抽象：定义一个结构体时候，实际上就是把一类事物的公有的属性（字段）或行为（方法）提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。

    加 * 的意思是定义为指针类型，后面好对内存中真实的数据进行实际修改

go的交互 数据输入方式
https://blog.csdn.net/weixin_45794641/article/details/124645893
第一种：这个可以

var cmdString string
fmt.Scanf("%s", &cmdString)
fmt.Println(cmdString)

第二种：字节类型 这个不能用数字来

reader := bufio.NewReader(os.Stdin)
cmdString, err := reader.ReadString('\\n')
cmdString = strings.TrimSuffix(cmdString, "\\n")
// cmd := exec.Command(commandString)
// cmd.Stderr = os.Stderr
// cmd.Run()

封装

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

封装的理解和好处
（1）隐藏实现细节
（2）可以对数据进行验证，保证安全合理

如何体现封装
（1）对结构体中的属性进行封装
（2）通过方法，包 实现封装

小写的变量作为struct则只能本包实现

封装的实现步骤
1）将 结构体、字段（属性）的首字母小写 （不能导出，其它包不能使用，类似private）
2）给结构体所在包提供一个工厂模式的函数，首字母大写。类似一个构造函数
3）提供一个首字母大写的Set方法（类似其它语言的public），用于对属性判断并赋值

func（var结构体类型名）SetXxox（参数列表）（返回值列表）
	//加入数据验证的业务逻辑
	var.字段=参数

4）提供一个首字母大写的Get方法（类似其它语言的public），用于获取属性的值

func（var结构体类型名）Getxxx）
	return var.字段;

模板：
person.go

package model
import "fmt"

type person struct 
	Name string
	age int   //小写其它包不能直接访问..
	sal float64


//写一个工厂模式的函数，相当于构造函数
//func 函数名(参数列表) (返回值列表) 
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("年龄范围不正确..")
		//给程序员给一个默认值
	


// 这里的int表示返回值类型，()表示不传参
// func (参数列表) Get方法名(传参) 返回值类型 
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"
	"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())


main.go

package main

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

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

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,
	



//方法
//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)

继承

go是没有继承的，但面对相同的代码，如何避免代码冗余？ （匿名结构体）

  • 当多个结构体存在相同的属性（字段）和方法时，可以从这些结构体中抽象出结构体（比如Student），在该结构体中定义这些相同的属性和方法。
  • 通过一个struct嵌套另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承的特性

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

type Goods struct 
	Name string
	Price int


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

匿名结构体

package main

import (
	"fmt"
)

//编写一个学生考试系统
type Student struct 
	Name  string
	Age   int
	Score int


//将Pupil 和 Graduate 共有的方法也绑定到 *Student
func (stu *Student) ShowInfo() 
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\\n", stu.Name, stu.Age, stu.Score)

func (stu *Student) SetScore(score int) 
	//业务判断
	stu.Score = score


//给 *Student 增加一个方法，那么 Pupil 和 Graduate都可以使用该方法
func (stu *Student) GetSum(n1 int, n2 int) int 
	return n1 + n2


//小学生
type Pupil struct 
	Student //嵌入了Student匿名结构体


//这时Pupil结构体特有的方法，保留
func (p *Pupil) testing() 
	fmt.Println("小学生正在考试中.....")


//大学生
type Graduate struct 
	Student //嵌入了Student匿名结构体


//这时Graduate结构体特有的方法，保留
func (p *Graduate) testing() 
	fmt.Println("大学生正在考试中.....")


//代码冗余.. 高中生....

func main() 

	//当我们对结构体嵌入了匿名结构体使用方法会发生变化
	pupil := &Pupil
	pupil.Student.Name = "tom~"
	pupil.Student.Age = 8
	pupil.testing()
	pupil.Student.SetScore(70)
	pupil.Student.ShowInfo()
	fmt.Println("res=", pupil.Student.GetSum(1, 2))


	// 匿名结构体 简写写法，编译器会自己去找本地的，如果不存在就去嵌入的匿名结构体
	graduate := &Graduate
	graduate.Name = "mary~"
	graduate.Age = 28
	graduate.testing()
	graduate.SetScore(90)
	graduate.ShowInfo()
	fmt.Println("res=", graduate.GetSum(10, 20))

  • 当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问，如希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分。 先查自己有没有，逐级的查，查到了距离自己最近的，就屏蔽其他的

  • 结构体嵌入两个（或多个）匿名结构体，如两个匿名结构体有相同的字段和方法（同时结构体本身没有同名的字段和方法），在访问时就必须明确指定匿名结构体名字，否则编译报错

  • 有名结构体，必须指定才能调用，如果D中是一个有名结构体，则访问有名结构体的字段时，就必须带上有名结构体的名字，d.a.Name

  • 嵌套多个匿名结构体（多重继承，尽量不使用），直接指定各个匿名结构体字段的值

接口

文件

1、文件的基本介绍：
文件在程序中以流的形式来操作的。
文件——》（输入流）——》Go程序（内存）
流：数据在数据源（文件）和程序（内存）之间经历的路径
输入流（读文件）：数据从数据源（文件）到程序（内存）的路径
输出流（写文件）：数据从程序（内存）到数据源（文件）的路径

os.File封装所有文件相关操作，File是一个结构体

type File struct 
    // 内含隐藏或非导出字段

https://studygolang.com/static/pkgdoc/pkg/os.htm#File

2、打开文件和关闭文件

  1. 打开一个文件进行读和写操作：
func Open(name string) (file *File, err error)
Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。

func (f *File) Close() error
Close关闭文件f，使文件不能用于读写。它返回可能出现的错误。

package main
import (
	"fmt"
	"os" 
)
func main() 
	//打开文件
	//概念说明: file 的叫法，三个叫法都是一个意思
	//1. file 叫 file对象
	//2. file 叫 file指针
	//3. file 叫 file 文件句柄
	file , err := os.Open("d:/test.txt")
	if err != nil 
		fmt.Println("open file err=", err)
	
	//输出下文件，看看文件是什么, 看出file 就是一个指针 *File
	fmt.Printf("file=%v", file)
	//关闭文件
	err = file.Close()
	if err != nil 
		fmt.Println("close file err=", err)

3、读文件：读取文件的内容并显示在终端（带缓冲区的方式 bufio.NewReader）
使用os.Open，file.Close，bufio.NewReader()，reader.ReadString函数和方法

package main
import (
	"fmt"
	"os"
	"bufio"
	"io" 
)
func main() 
	//打开文件
	//概念说明: file 的叫法
	//1. file 叫 file对象
	//2. file 叫 file指针
	//3. file 叫 file 文件句柄
	file , err := os.Open("d:/test.txt")
	if err != nil 
		fmt.Println("open file err=", err)
	

	//defer 当函数退出时，要及时的关闭file
	defer file.Close() //要及时关闭file句柄，否则会有内存泄漏.

	// 创建一个 *Reader  ，是带缓冲的
	/*
	const (
	defaultBufSize = 4096 //默认的缓冲区为4096
	)
	*/
	reader := bufio.NewReader(file)
	//循环的读取文件的内容
	for 
		str, err := reader.ReadString('\\n') // 每读到一个换行符就结束
		if err == io.EOF  // io.EOF表示文件的末尾
		//如果文件读到最后一行readstring就会返回一个io.Eof
			break
		
		//输出内容
		fmt.Printf(str)
	

	fmt.Println("文件读取结束...")

defer：处理业务或逻辑中涉及成对的操作是一件比较烦琐的事情，比如打开和关闭文件、接收请求和回复请求、加锁和解锁等。在这些操作中，最容易忽略的就是在每个函数退出处正确地释放和关闭资源。
defer 语句正好是在函数退出时执行的语句，所以使用 defer 能非常方便地处理资源释放问题。

4、读文件：读取文件的内容并显示在终端（使用ioutil一次将整个文件读入到内存中）
这种方式适用于文件不大的情况。

func ReadFile(filename string) ([]byte, error)
ReadFile 从filename指定的文件中读取数据并返回文件的内容。成功的调用返回的err为nil而非EOF。因为本函数定义为读取整个文件，它不会将读取返回的EOF视为应报告的错误。

package main
import (
	"fmt"
	"io/ioutil" 
)
func main() 

	//使用ioutil.ReadFile一次性将文件读取到位
	file := "d:/test.txt"
	content, err := ioutil.ReadFile(file)
	if err != nil 
		fmt.Printf("read file err=%v", err)
	
	//把读取到的内容显示到终端
	//fmt.Printf("%v", content) // []byte
	fmt.Printf("%v", string(content)) // []byte
	
	//我们没有显式的Open文件，因此也不需要显式的Close文件
	//因为，文件的Open和Close被封装到 ReadFile 函数内部

5、写文件：基本应用实例（一）

func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式（如0666等）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。

第二个参数：

const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
)

第三个参数是权限777控制

应用实例：
1）创建一个新文件，写入内容5句"hello，Gardon"
os.O_WRONLY | os.O_CREATE
2）打开一个存在的文件中，将原来的内容覆盖成新的内容10句“你好，尚硅谷！"
os.O_WRONLY | os.O_TRUNC
3）打开一个存在的文件，在原来的内容追加内容’ABC！ENGLISH！！"
os.O_WRONLY | os.O_APPEND
4）打开一个存在的文件，将原来的内容读出显示在终端，并且追加5句“hello，北京！"
os.O_RDWR | os.O_APPEND

使用os.OpenFile(),bufio.NewWriter(),*Writer的WriterString

package main
import (
	"fmt"
	"bufio"
	"os" 
)
func main() 
	//创建一个新文件，写入内容 5句 "hello, Gardon"
	//1 .打开文件 d:/abc.txt
	filePath := "d:/abc.txt"
	file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_CREATE, 0666)
	if err != nil 
		fmt.Printf("open file err=%v\\n", err)
		return 
	
	//及时关闭file句柄
	defer file.Close()
	//准备写入5句 "hello, Gardon"
	str := "hello,Gardon\\r\\n" // \\r\\n 表示换行
	//写入时，使用带缓存的 *Writer
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ 
		writer.WriteString(str)
	
	//因为writer是带缓存，因此在调用WriterString方法时，其实
	//内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
	//真正写入到文件中， 否则文件中会没有数据!!!
	writer.Flush()

6、写文件：基本应用实例（二）
编程一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了.
说明：使用ioutil.ReadFile/ioutil.WriteFile完成写文件的任务.
代码实现：

package main
import (
	"fmt"
	"io/ioutil" 
)
func main() 
	//将d:/abc.txt 文件内容导入到  e:/kkk.txt
	//1. 首先将  d:/abc.txt 内容读取到内存
	//2. 将读取到的内容写入 e:/kkk.txt
	file1Path := "d:/abc.txt" 
	file2Path := "e:/kkk.txt" 
	data, err := ioutil.ReadFile(file1Path)
	if err != nil 
		//说明读取文件有错误
		fmt.Printf("read file err=%v\\n", err)
		return
	
	err = ioutil.WriteFile(file2Path, data, 0666)
	if err != nil 
		fmt.Printf("write file error=%v\\n", err)

7、写文件：基本应用实例（三）拷贝文件

package main
import (
	"fmt"
	"os"
	"io"
	"bufio" 
)

//自己编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) 

	srcFile, err := os.Open(srcFileName)
	if err != nil 
		fmt.Printf("open file err=%v\\n", err)
	
	defer srcFile.Close()
	//通过srcfile ,获取到 Reader
	reader := bufio.NewReader(srcFile)

	//打开dstFileName
	dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
	if err != nil 
		fmt.Printf("open file err=%v\\n", err)
		return 
	
	//通过dstFile, 获取到 Writer
	writer := bufio.NewWriter(dstFile)
	defer dstFile.Close()

	
《go语言精进之路》读书笔记|使用go语言原生编码思维来写go代码(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

go语言学习记录1——开始go语言学习之路(代码片段)


零.前言我学Go的目的是，因为Go语言本身就是一个编译型语言，相较于Python，可能会有更好的执行效率。Go语言原生支持并发，对于高并发任务肯定会优于Python。所以为了以后想做的分布式集群以及一些零零散散的...  查看详情  

                

go语言学习之路go语言中的变量(代码片段)


⭐️写在前面这里是温文艾尔的学习之路👍如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ👋博客主页🎉温文艾尔的学习小屋⭐️更多文章👨‍🎓请关注温文艾尔主页📝🍅文章发布日期&...  查看详情  

                

go语言学习之路(代码片段)


Go语言学习之路（二）面对对象编程思想抽象封装继承接口文件命令行参数Json序列化反序列化（unmarshal）单元测试RedisRedis简介Redis基本使用Go连接redisRedis连接池Go面试题goroutine和channel（275-283）协程goroutine...  查看详情  

                

《go语言精进之路》读书笔记|理解go语言代码块与作用域(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

go语言学习之路结构体实战(代码片段)


...收藏⭐️🎄冲冲冲🎄⭐️上一篇内容：【GO语言学习之路】GO语言中的变量文章目录实战目标，利用结构体等实现对学生的增加修改查询packagemainimport"fmt"//学员信息管理系统/**1.学生有id、姓名、年龄、分数...  查看详情  

                

《go语言精进之路》读书笔记|使用无类型常量简化代码(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|理解go语言的设计哲学(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|使用go语言原生编码思维来写go代码(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|提交前使用gofmt格式化源码(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|使用iota实现枚举常量(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|使用得到公认且广泛使用的项目结构(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

go语言学习之路-2-变量与常量(代码片段)


标识符与关键字标识符定义变量时，我们定义了:name、age这样的名字，它们都是程序员自己起的，能够表达出变量的作用，这叫做标识符（Identifier）标识符就是程序员自己起的名字，名字也不能随便起，要遵守规范，在Go语言中...  查看详情  

                

go语言学习之路go语言中的变量(代码片段)


⭐️写在前面这里是温文艾尔的学习之路👍如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ👋博客主页🎉温文艾尔的学习小屋⭐️更多文章👨‍🎓请关注温文艾尔主页📝🍅文章发布日期&...  查看详情  

                

《go语言精进之路》读书笔记|理解go语言的包导入(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|理解go语言表达式的求值顺序(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

《go语言精进之路》读书笔记|使用复合字面值作为初值构造器(代码片段)


书籍来源：《Go语言精进之路：从新手到高手的编程思想、方法和技巧》一边学习一边整理读书笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：《Go语言精进之路》读书笔记|汇总_COCOgsta的博...  查看详情  

                

先睹为快，go2error的挣扎之路(代码片段)


若有任何问题或建议，欢迎及时交流和碰撞。我的公众号是【脑子进煎鱼了】，GitHub地址：https://github.com/eddycjy。大家好，我是煎鱼。自从Go语言在国内火热以来，除去泛型，其次最具槽点的就是Go对错误的处理方式，一句经典的...  查看详情