go基础 结构体

关键字type

用法1：给变量定义别名，增加代码可读性

用法2：基于已有类型定义新的类型

程序示例：

package main

import "fmt"

func main() {
	// 用法一：给类型定义别名
	type myByte = byte
	var b myByte
	var a byte
	fmt.Printf("%T\n", b)
	fmt.Printf("%T\n", a)

	// 用法二：基于已有类型定义新的类型
	type myInt int
	var i myInt
	fmt.Printf("%T\n", i)
}

运行结果：

uint8
uint8
main.myInt

用法3：定义结构体

程序示例：

package main

import "fmt"

type Course struct {
	name string
	age int
}

func main() {
	var tom = Course{
		name: "ZhangLiang",
		age: 18,
	}
	fmt.Println(tom)
}

运行结果：

{zhangliang 18}

用法4：定义接口

用法5：定义函数别名

结构体封装属性

封装主要对变量（数据）和方法的封装，go语言的struct具有封装的功能，更像python中的类型namedtumple(from collections import namedumple)。

程序示例：

package main

import "fmt"

type Course struct {
	name string
	price int
	url string

	//结构体中不能定义函数
}
func main() {
	// 面向对象的三大特征：封装 继承 多态，除此而外还有方法重载和抽象基类等特征
	// go没有class的概念，不支持面向对象，但是go语言解决了面向对象的三大特征问题。


	var c Course = Course{
		name: "Django",
		price:100,
		url: "https://www.go.com",
	}

	fmt.Println(c)
	fmt.Println(c.name)
}

运行结果：

{Django 100 https://www.go.com}
Django

大小写在go语言中的重要性：一个包中的小写首字母变量或小写首字母的结构体对其他包是不可见的。

结构体的实例化方式

上面的内容实际上我们已经学会了结构体的一种实例化方式。

此外，结构体还有另外一种方式实现结构体，注意此种方式一定要顺序写结构体的属性。

程序示例：

package main

import "fmt"

type Course struct {
	name string
	price int
	url string

	//结构体中不能定义函数
}
func main() {

	// 实例化方式2
	c2 := Course{"python", 110, "http://www.bai.com"}
	fmt.Println(c2)
	fmt.Println(c2.name)
}

运行结果：

{python 110 http://www.bai.com}
python

指向结构体的指针如何实例化，如何获取对象的值？

程序示例：

package main

import "fmt"

type Course struct {
	name string
	price int
	url string

	//结构体中不能定义函数
}
func main() {

	// 指向结构体的指针
	c3 := &Course{"java", 140, "http://www.du.com"}
	fmt.Printf("%T\n", c3)
	fmt.Println((*c3).name, (*c3).price, (*c3).url)
    // 提供了语法糖，实际内部做了强制转为（*c3）导致也能输出,也是因为go语言的指针是受限的，不能做偏移等 *** 作，保证了安全性
	fmt.Println(c3.name, c3.price, c3.url)    
}

运行结果：

*main.Course
java 140 http://www.du.com
java 140 http://www.du.com

 如果不给结构体赋值，实例化的结构体会默认给每个字段采用默认值。

结构体是值类型，在传递的时候是值传递。

程序示例：

package main

import "fmt"

type Course struct {
	name string
	price int
	url string

	//结构体中不能定义函数
}
func main() {

	// 实例化方式2
	c2 := Course{"python", 110, "http://www.bai.com"}


	// 结构体的传递是值传递
	c8 := c2
	fmt.Println(c8)
	fmt.Println(c2)
	c8.price = 220
	fmt.Println(c8)
	fmt.Println(c2)

}

运行结果:

{python 110 http://www.bai.com}
{python 110 http://www.bai.com}
{python 220 http://www.bai.com}
{python 110 http://www.bai.com}

结构体的空间大小

结构体占用内存空间的大小，可以使用sizeof来查看对象占用的类型。

        程序示例：

package main

import "unsafe"

type Course struct {
	name string
	price int
	url string

	//结构体中不能定义函数
}

func main() {
	println(unsafe.Sizeof(9))
	println(unsafe.Sizeof(""))
	println(unsafe.Sizeof(Course{}))	// 18+8+16=40
}

运行结果：

8
16
40

 其实，go语言中结构体无处不在，string，slice的本质都是结构体。

而对于python，一切皆对象。

 结构体封装方法

结构体可以绑定方法，但是使用的时候需要注意结构体的传递是值传递，如果需要修改，则需要使用指针。

程序示例：

package main

import "fmt"

type Course struct {
	name string
	price int
	url string
}

// (c Course)被叫做函数的接收者
func (c Course) printCourseInfo () {
	fmt.Printf("课程名：%s, 课程价格：%d, 课程地址：%s\n", c.name, c.price, c.url)
}

func (c Course) setPrice(price int) {
	c.price = price
}

func (c *Course) setPrice2(price int) {		//结构体指针
	c.price = price
}

func main() {
	c1 := Course{"python", 110, "www.baudu.comn"}
	c1.printCourseInfo()
	Course.printCourseInfo(c1)
	
	// 结构体的引用是值传递，不使用指针无法修改
	c1.setPrice(200)
	fmt.Println(c1.price)	// 不使用指针无法修改

	c1.setPrice2(200)
	fmt.Println(c1.price)	// 使用指针可以修改

}

运行结果：

课程名：python, 课程价格：110, 课程地址：www.baudu.comn
课程名：python, 课程价格：110, 课程地址：www.baudu.comn
110
200