go语言【结构体-封装】
一. type
1. 作用
1. 给一个类型定义 别名, 实际上为什么会有byte， 就是我为了强调我们现在处理的对象是字节类型 这种别名实际上还是为了代码的可读性， 这个实际上本质上仍然是uint8 无非就是在代码编码阶段可读性强而已
2. 第二种 就是基于一个已有的类型定义一个新的类型
3. 定义结构体
4. 定义接口
5. 定义函数别名
2. 代码示例
func main() {
//go语言中的关键词 type
//1. 给一个类型定义 别名, 实际上为什么会有byte， 就是我为了强调我们现在处理的对象是字节类型 这种别名实际上还是为了代码的可读性， 这个实际上本质上仍然是uint8 无非就是在代码编码阶段可读性强而已
type myByte = byte
var b uint8
fmt.Printf("%T\n", b)
//2. 第二种 就是基于一个已有的类型定义一个新的类型
type myInt int
var i myInt
fmt.Printf("%T\n", i)
//3. 定义结构体
//4. 定义接口
//5. 定义函数别名
}
二. 结构体定义
1. 定义结构体及实例化- kv形式
大小写：
大小写在go语言中的重要性 可见性
一个包中的变量或者结构体如果首字母是小写 那么对于另一个包不可见
机构体定义的 名称 以及属性首字母大写很重要
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//go语言不支持面向对象
//面向对象的三个基本特征： 1. 封装 2. 继承 3. 多态 4. 方法重载 4. 抽象基类
//定义struct go语言没有class这个概念 所以说对于很多人来说会少理解很多面向对象抽象的概念
//1. 实例化- kv形式
var c Course = Course{
Name: "django",
Price: 100,
Url: "https://www.123.com",
}
//访问
fmt.Println(c.Name, c.Price, c.Url)
}2. 定义结构体及实例化- 顺序形式
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//2. 第二种实例化方式 - 顺序形式
c2 := Course{"scrapy", 110, "https://www.imooc.com"}
fmt.Println(c2.Name, c2.Price, c2.Url)
}
3. 定义结构体及实例化-如果一个指向结构体的指针
如果一个指向结构体的指针, 通过结构体指针获取对象的值， 让很多人莫名其妙
应该能看出来 go语言实际上在借鉴动态语言的特性 - 很多地方不管如何写都是正确的
另一个根本的原因 - go语言的指针是受限的
fmt.Println(c3.Name, c3.Price, c3.Url) 这里其实是go语言的一个语法糖 go语言内部会将c3.Name转换成 (*c3).Name
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//3. 如果一个指向结构体的指针, 通过结构体指针获取对象的值， 让很多人莫名其妙
c3 := &Course{"tornado", 100, "https://www.imooc.com"}
//fmt.Printf("%T", c3)
//应该能看出来 go语言实际上在借鉴动态语言的特性 - 很多地方不管如何写都是正确的
//另一个根本的原因 - go语言的指针是受限的
fmt.Println(c3.Name, c3.Price, c3.Url) //这里其实是go语言的一个语法糖 go语言内部会将c3.Name转换成 (*c3).Name
}4. 定义结构体及实例化-结构体的零值
如果不给结构体赋值， go语言会默认给每个字段采用默认值
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//零值 如果不给结构体赋值， go语言会默认给每个字段采用默认值
c4 := Course{}
fmt.Println(c4.Price)
// 输出：0
}
5. 定义结构体及实例化-多种方式零值初始化结构体
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//5. 多种方式零值初始结构体
var c5 Course = Course{}
var c6 Course
var c7 *Course = &Course{}
var c8 *Course
//为什么c6和c8表现出来的结果不一样 指针如果只申明不赋值 默认值是nil c6不是指针 是结构体的类型
//slice map
fmt.Println("零值初始化")
fmt.Println(c5.Price)
fmt.Println(c6.Price)
fmt.Println(c7.Price)
fmt.Println(c8.Price)
//输出
//0
//0
//0
//报错
}
6. 定义结构体及实例化-结构体是值类型
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//6. 结构体是值类型
c8 := Course{"scrapy", 110, "https://www.imooc.com"}
c9 := c8
fmt.Println(c8)
fmt.Println(c9)
c8.Price = 200
fmt.Println(c8) //200
fmt.Println(c9) //100
}7. 定义结构体及实例化-结构体的大小
package main
import (
"fmt"
"unsafe"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//7. 结构体的大小 占用内存的大小 可以使用sizeof来查看对象占用的类型
fmt.Println(unsafe.Sizeof(1))
//go语言string的本质 其实string是一个结构体
fmt.Println(unsafe.Sizeof(""))
fmt.Println(unsafe.Sizeof(c8))
}
7. 定义结构体及实例化-slice的大小
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func main() {
//8. slice的大小
type slice struct {
array unsafe.Pointer // 底层数组的地址
len int // 长度
cap int // 容量
}
s1 := []string{"django", "tornado", "scrapy", "celery", "snaic", "flask"}
fmt.Println("切片占用的内存:", unsafe.Sizeof(s1))
//24
m1 := map[string]string{
"bobby1": "django",
"bobby2": "tornado",
"bobby3": "scrapy",
"bobby4": "celery",
}
fmt.Println(unsafe.Sizeof(m1))
//8
}三. 结构体-绑定方法
golang语言是怎么实现python class的调用方式呢
函数的接收者， 在函数的前面加上c Course，其实就是将strut将函数绑定起来了， c 相当与python类对象中的self
type Course struct {
Name string
Price int
Url string
}
func (c Course) printCourseInfo() {
fmt.Printf("课程名:%s, 课程价格: %d, 课程的地址:%s", c.Name, c.Price, c.Url)
}怎么实现以上的调用呢
//结构体方法， 达到了封装数据和封装方法的效果
c10 := Course{"scrapy", 110, "https://www.imooc.com"}
c10.printCourseInfo() //就完成了函数的调用但是会出现一个问题，当我们去修改price的值后会发生什么
可见，输出110，实际并没有改变值，这是为什么呢
c10.setPrice(300)的本质是 Course.setPrice(c10, 300) ， c10.setPrice(300)其实是语法糖，是内部都进行转换的。 而函数的参数是怎么传递的，取决于c10的类型是什么类型，c10是结构体，是值传递， 意味着传递进去后会c10会被复制一份，所以是修改不了的
然后怎么来修改呢
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
func (c Course) printCourseInfo() {
fmt.Printf("课程名:%s, 课程价格: %d, 课程的地址:%s", c.Name, c.Price, c.Url)
}
func (c Course) setPrice(price int) {
c.Price = price
}
func main() {
//结构体方法， 达到了封装数据和封装方法的效果
c10 := Course{"scrapy", 110, "https://www.imooc.com"}
//Course.setPrice(c10, 300) // 本质
c10.setPrice(300)
fmt.Println(c10.Price)
// 输出110
}使用指针，可以进行值的修改
结构体的接收者有两种形式
1. 值传递
2. 指针传递 如果你想改结构体的值,就用指针， 如果结构体的数据很大，也使用指针，增加性能
package main
import (
"fmt"
)
type Course struct {
Name string
Price int
Url string
}
//1. 结构体的方法只能和结构体在同一个包中
//2. 内置的int类型不能加方法，但是可以自己定义类型 type Myint int
// 函数的接收者， 在函数的前面加上c Course，其实就是将strut将函数绑定起来了
func (c Course) printCourseInfo() {
fmt.Printf("课程名:%s, 课程价格: %d, 课程的地址:%s", c.Name, c.Price, c.Url)
}
func (c *Course) setPrice(price int) {
c.Price = price
}
func main() {
//结构体方法， 达到了封装数据和封装方法的效果
c10 := Course{"scrapy", 110, "https://www.imooc.com"}
c10.setPrice(300)
fmt.Println(c10.Price)
(&c10).setPrice(200) //修改c10的price? 为什么呢？ 语法糖 函数参数的传递是怎么传递的？ 结构体是值传递
c10.setPrice(210) // 和上面的调用方式结果其实是一样的，go内部其实做了转换
fmt.Println(c10.Price)
c10.printCourseInfo()
//结构体的接收者有两种形式 1. 值传递 2. 指针传递 如果你想改结构体的值,就用指针， 如果结构体的数据很大，也使用指针，增加性能
//go语言不支持继承 但是有办法能达到同样的效果 组合
}完整测试代码
package main
import (
"fmt"
"unsafe"
)
// Course类名，struct关键字
type Course struct {
Name string
Price int
Url string
}
//函数的接收者，将Course struct进行绑定
func (c Course) printCourseInfo() {
fmt.Printf("课程名:%s, 课程价格: %d, 课程的地址:%s", c.Name, c.Price, c.Url)
}
//修改价格
func (c *Course) setPrice(price int) {
c.Price = price
}
//1. 结构体的方法只能和结构体在同一个包中
//2. 内置的int类型不能加方法
func main() {
//go语言不支持面向对象
//面向对象的三个基本特征： 1. 封装 2. 继承 3. 多态 4. 方法重载 4. 抽象基类
//定义struct go语言没有class这个概念 所以说对于很多人来说会少理解很多面向对象抽象的概念
//1. 实例化- kv形式
var c Course = Course{
Name: "django",
Price: 100,
Url: "https://www.imooc.com",
}
//访问
fmt.Println(c.Name, c.Price, c.Url)
//大小写在go语言中的重要性 可见性
//一个包中的变量或者结构体如果首字母是小写 那么对于另一个包不可见
//机构体定义的 名称 以及属性首字母大写很重要
//2. 第二种实例化方式 - 顺序形式
c2 := Course{"scrapy", 110, "https://www.imooc.com"}
fmt.Println(c2.Name, c2.Price, c2.Url)
//3. 如果一个指向结构体的指针, 通过结构体指针获取对象的值， 让很多人莫名其妙
c3 := &Course{"tornado", 100, "https://www.imooc.com"}
//fmt.Printf("%T", c3)
//应该能看出来 go语言实际上在借鉴动态语言的特性 - 很多地方不管如何写都是正确的
//另一个根本的原因 - go语言的指针是受限的
fmt.Println(c3.Name, c3.Price, c3.Url) //这里其实是go语言的一个语法糖 go语言内部会将c3.Name转换成 (*c3).Name
//4. 零值 如果不给结构体赋值， go语言会默认给每个字段采用默认值
c4 := Course{}
fmt.Println(c4.Price)
//5. 多种方式零值初始结构体
var c5 Course = Course{}
var c6 Course
var c7 *Course = &Course{}
//或者
//var c7 *Course = new(Course)
//var c8 *Course
//为什么c6和c8表现出来的结果不一样 指针如果只申明不赋值 默认值是nil c6不是指针 是结构体的类型
//slice map
fmt.Println("零值初始化")
fmt.Println(c5.Price)
fmt.Println(c6.Price)
fmt.Println(c7.Price)
//6. 结构体是值类型
c8 := Course{"scrapy", 110, "https://www.imooc.com"}
c9 := c8
fmt.Println(c8)
fmt.Println(c9)
c8.Price = 200
//为值传递，不影响之前的赋值
fmt.Println(c8)
fmt.Println(c9)
//go语言中struct无处不在
//7. 结构体的大小 占用内存的大小 可以使用sizeof来查看对象占用的类型
fmt.Println(unsafe.Sizeof(1))
//go语言string的本质 其实string是一个结构体
fmt.Println(unsafe.Sizeof(""))
fmt.Println(unsafe.Sizeof(c8))
//8. slice的大小
type slice struct {
array unsafe.Pointer // 底层数组的地址
len int // 长度
cap int // 容量
}
s1 := []string{"django", "tornado", "scrapy", "celery", "snaic", "flask"}
fmt.Println("切片占用的内存:", unsafe.Sizeof(s1))
m1 := map[string]string{
"bobby1": "django",
"bobby2": "tornado",
"bobby3": "scrapy",
"bobby4": "celery",
}
fmt.Println(unsafe.Sizeof(m1))
//结构体方法， 达到了封装数据和封装方法的效果
c10 := Course{"scrapy", 110, "https://www.imooc.com"}
//Course.setPrice(c10, 200) 本质是这样的
(&c10).setPrice(200) //修改c10的price? 为什么呢？ 语法糖 函数参数的传递是怎么传递的？ 结构体是值传递,所以通过 c10.setPrice(200)修改是无效的，需要将fun修改为指针 func (c *Course)
//c10.setPrice(200)和(&c10).setPrice(200) 调用效果是一样的，结构体是内部自己将指针做装换
fmt.Println(c10.Price)
c10.printCourseInfo()
//结构体的接收者有两种形式 1. 值传递 2. 指针传递 应用：如果你想改结构体的值 如果结构体的数据很大
//go语言不支持继承 但是有办法能达到同样的效果 组合
}
浙公网安备 33010602011771号