Go语言结构体与面向对象-优快云博客

本文链接：https://blog.youkuaiyun.com/super2feng/article/details/113591544

更新系列

Go语言头秃之路（零）
Go语言头秃之路（一）
Go语言头秃之路（二）
Go语言头秃之路（三）
Go语言头秃之路（五）
Go语言头秃之路（六）
Go语言头秃之路（七）

面向对象（结构体）

结构体：自定义数据类型
结构体是值类型。
定义：

type 结构体名 struct {
	属性名1 类型1
	属性名2 类型2
}

结构体四种实例创建方式：

type Stu struct {
	Name string
	Age int
}
// 1. 
var s1 Stu
// 2. 
s2 := Stu{"tony", 10}
s2_2 := &Stu{"tony", 10}   // 实例化为指针类型变量，存的是地址，多用于工厂模式
// 3. 这里s3.Name == (*s3).Name，go编译器会将s3转义成(*s3)，s4同
var s3 *Stu = new(Stu)
// 4. 
var s4 *Stu = &Stu{}

如果结构体的字段类型(引用类型)是指针、slice、map，他们的零值是nil，即没有分配空间，在字段使用之前需要先make()

结构体的所有字段在内存中是连续的

两个结构体无法进行转换（赋值=），取别名也不行，因为golang会认为这是两种数据类型，强制转换时字段要完全一样（包括名称、个数）

type A struct {num int}
type B struct {n int}
var a A
var b B
a = b // 报错
a = B(b)  // 强制转换

结构体的大小是声明中各元素指针大小之和（string指针占16字节，int指针占8字节），可以使用unsafe.SizeOf() 查看。（go语言中string本质是结构体）
- 方法作用在指定数据类型上，所有自定义类型都可以有方法。
  自定义数据类型会作为参数传递给方法，如果数据类型是值类型则进行值拷贝，如果是引用类型则进行地址拷贝。
  结构体是值拷贝, 为了提高效率一般将方法和结构体的指针类型绑定：
  func (结构体形参 *结构体名) 方法名(方法参数1,…) {
  fmt.Println("…")
  }
  饭粒：
  func (a *A) test() {
  fmt.Println("…")
  }
  test()方法与结构体A绑定，只能通过A的实例调用。
  如果自定义类型绑定了自定义String方法，那么在打印地址时会按照自定义的String返回值输出。
- 方法和函数的区别：
1. 调用方式不一样
2. 对于函数，形参为值类型时不能将指针类型的数据作为实参传递，反之同理；
  对于方法（如struct的方法），形参和实参不论值类型还是指针类型都可以相互调用。
  注意：不管调用形式如何，真正决定是值拷贝还是地址拷贝得看这个方法是和哪个类型绑定。如果是和值类型绑定，比如(u User)，则是值拷贝，如果是和指针类型绑定，如(u *User)，则是地址拷贝。
```
package main

import "fmt"

type User struct {
	Name string
}

func (u User) change() {   // 因为形参是值类型，所以实参不论是值传递还是引用传递都是值拷贝
	u.Name = "yiming"
	fmt.Println("change() User.Name:", u.Name)
}

func main()  {
	u1 := User{"fone"}
	(&u1).change()   // 值拷贝
	fmt.Println("main() User.Name:", u1.Name)
}
```
- 面向对象特性
  - 封装：逻辑写在方法中
  - 继承：消灭代码冗余
    通过嵌入匿名结构体实现：声明的时候加上一行需要继承的结构体名即可
  说明：
  1. 继承过来的结构体所有属性和方法都可以使用（不论首字母大小写都可以）
  2. 匿名结构体的属性和方法调用可以简化匿名结构体名，查找顺序是（就近原则）：先找当前结构体的属性方法，如果没有就找继承结构体的属性方法。
  3. 结构体嵌入两个（或多个）匿名结构体时，如果两个匿名结构体有同名字段或方法，而当前结构体没有同名字段方法，在调用时必须指定匿名结构体名，否则编译报错。(为了代码简洁性，尽量不要使用多重继承)
  4. 如果嵌入的是有名结构体（匿名结构体前带上别名），则调用属性方法时必须带上有名结构体别名。
  5. 嵌入匿名结构体使用指针类型会比较高效。
```
package main

import "fmt"

type Product struct {
	Name string
	Price float64
}

type SuperMarket struct {
	Name string
	Address string
}

type cup struct {
	p *Product
	*SuperMarket
}

func (p *Product) Card() {
	fmt.Println("商品: ", p.Name, "\t价格：", p.Price)
}

func (sm *SuperMarket) MarketInfo() {
	fmt.Println("商场: ", sm.Name, "\t地址：", sm.Address)
}

func main()  {
	c1 := cup{
		&Product{
			Name: "杯具001", 
			Price: 12.34,
		}, 
		&SuperMarket{
			Name: "人人乐", 
			Address: "学府路58号",
		},
	}
	c1.p.Card()
	c1.MarketInfo()
	fmt.Println(c1.Name)
}
```
- 接口interface
  接口名一般使用er结尾；
  用于定义一组方法，但不需要实现。
  接口不能包含任何变量。
  定义接口函数时不能使用指针接收器。
  在自定义类型（如结构体）的时候，再把这些方法通通实现。
  接口定义中的所有方法都没有方法体（即都是没有实现的方法），接口体现了程序设计的多态和高内聚低耦合思想。
  接口只要一个变量，含有接口类型中的所有方法，那么这个变量就实现了这个接口。
  语法：
```
type 接口名 interface{
	方法1(参数列表) [返回值列表]
	方法2(参数列表) [返回值列表]
}

func (自定义类型别名 自定义类型) 方法1(参数列表) [返回值列表] {实现逻辑}...
```
  注意：
  1. 接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型变量（实例）；
  2. 任何自定义类型都可以实现接口，一个自定义类型可以实现多个接口；
  3. 接口可以继承多个接口，此时自定义类型需要实现所有方法。但是不允许继承的接口存在相同的方法，即一个接口（包括继承过来的接口）中不能存在相同的方法。
  4. 接口类型默认是一个指针（引用类型），没有初始化时为nil；
  5. 空接口interface{}没有任何方法，所有类型都实现了空接口，任何变量都可以赋值给空接口。
  6. 接口可以在不破坏继承关系的基础上增加方法，实现接口是对继承的补充。
- 接口&继承
1. 继承的价值：解决代码复用性和可维护性；
2. 接口的价值：设计好各种规范（方法），让其他自定义类型去实现这些方法。
3. 接口比继承更加灵活：继承是满足 is - a 的关系，而接口只需满足 like - a 的关系。
- 多态
  变量（实例）具有多种形态。
  多态通过接口实现。
  
  类型断言：当需要将一个接口变量赋值给自定义类型变量时使用类型断言。
  饭粒：
```
type Point struct {
	x int
	y int
}

func main()  {
	var a interface{}
	var point Point = Point{1,2}
	a = point  // 空接口可以接收任意类型

	var b Point
	// 类型断言
	// 判断a是否指向Point类型，如果是就转成Point类型并赋值给b，否则不抛异常。
	if b, ok = a.(Point); ok {
		fmt.Println(a, b)
	} else {
		fmt.Println("panic..")
	}
	fmt.Println("exec continue..")
}
```
  类型断言应用场景：
  1. 在实现多态时，自定义变量需要调用自己单独的方法时，使用断言判断变量类型。
  2. 用于判断数据类型，饭粒：
```
package main

import "fmt"

type Student struct {}

func GetType(items... interface{})  {
	for i, x := range items {
		switch x.(type) {
			case bool:
				fmt.Printf("第%v个值类型是 布尔, 值为：%v\n", i, x)
			case int, int32, int64:
				fmt.Printf("第%v个值类型是 整形, 值为：%v\n", i, x)
			case float32, float64:
				fmt.Printf("第%v个值类型是 浮点型, 值为：%v\n", i, x)
			case string:
				fmt.Printf("第%v个值类型是 字符串, 值为：%v\n", i, x)
			case Student:
				fmt.Printf("第%v个值类型是 学生, 值为：%v\n", i, x)
			case *Student:
				fmt.Printf("第%v个值类型是 学生指针, 值为：%v\n", i, x)
			default:
				fmt.Printf("第%v个值类型 不确定, 值为：%v\n", i, x)
		}
	}
}

func main()  {
	n1 := 1
	n2 := 1.1
	n3 := "hello"
	n4 := true
	n5 := Student{}
	n6 := &Student{}
	GetType(n1, n2, n3, n4, n5, n6)
}
```

Go语言头秃之路（四）

更新系列