语言特性

面相对象特性

继承: "is-a"; 组合: "has-a"。

比如狗和猫都是动物，即"is-a"，这种关系可以用继承来描述。

什么时候用继承? 什么时候用组合？

Golang 给出了答案：放弃继承，全面强化组合能力。

type Animal struct{
	name string
}

func (a Animal) Name() string{
	return a.name
}

func (a Animal) Eat() {
	fmt.Println(a.Name() + " is eating")
}

type Dog struct{
	Animal // 结构体的成员匿名内嵌另一个结构体，直接获得父结构体的字段、方法
}

type Cat struct{
	a Animal // 对比这种有名的内嵌方式，Cat不能直接获得Animal的字段、方法
}

func main() {
	dog := Dog{}
	cat := Cat{}
	dog.Eat()
	cat.a.Eat()
}

Dog 结构体内嵌了 Animal 结构体，因此可以使用 Animal 结构体的 name 字段以及 Name、Eat 方法，从感官上类似「继承」的效果，但实际上是「组合」。

Golang结构体的内嵌为什么不算继承？

继续上面的例子，如果实现的是如下Eat方法，那么Dog和Cat实例当参数传入Eat方法是会报错的: Cannot use 'dog' (type Dog) as the type Animal，如果是继承关系，那么显然是可以把子类当参数传入父类的，因此 Golang 的内嵌不存在继承关系，而属于组合关系。

func Eat(animal Animal) {
	fmt.Println(animal.Name() + " is eating")
}

为什么不推荐使用继承?

假设我们要设计一个关于鸟的类。我们将“鸟”这样一个抽象的事物概念，定义为一个抽象类AbstractBird。所有更细分的鸟，比如麻雀、鸽子、乌鸦等，都继承这个抽象类。我们知道，大部分鸟都会飞，那我们可不可以在 AbstractBird抽象类中，定义一个fly()方法呢？

答案是否定的。尽管大部分鸟都会飞，但也有特例，比如鸵鸟就不会飞，企鹅也不会飞。

要解决上面的问题，就得让AbstractBird类派生出两个更加细分的抽象类：会飞的鸟类AbstractFlyableBird和不会飞的鸟类AbstractUnFlyableBird。

进一步延伸，按“鸟会不会叫”再进行区分，这样就产生了4种情况：产生四种情况：会飞会叫、不会飞会叫、会飞不会叫、不会飞不会叫。

接下来进一步延伸，继续增加“鸟会不会下蛋”这样的行为，类的继承层次会越来越深、继承关系会越来越复杂。

在实际项目开发中，还会有层次更深更加复杂的业务场景，继承会产生非常复杂的对象继承树，子类的实现依赖父类的实现，两者高度耦合，实际项目开发难以一次性就考虑周全，一旦父类代码修改，就会影响所有子类的逻辑。

那么组合是如何解决问题的呢？组合结合接口来一起解决这个问题。

接口表示具有某种行为特性。针对“会飞”这样一个行为特性，可以定义一个Flyable接口，只让会飞的鸟去实现这个接口。对于会叫、会下蛋这些行为特性，可以类似地定义Tweetable接口、EggLayable接口。比如麻雀会飞会叫还会下蛋，该类型就同时组合实现这些接口，组合和接口的结合使用范例参考interface章节虚基类部分。

多态

// 重写内嵌Animal的Eat方法，那么子类Dog实例调用Eat方法时将触发本方法
// 若没有重写方法，则触发内嵌父类Animal的Eat方法
func (a Dog) Eat() {
	fmt.Printf("Dog %s is eating", a.Name())
}

type IAnimal interface {
	Eat() 
}

// 多态
// 接收所有满足IAnimal接口定义的类型，即实现了Eat方法的任何类型实例都可以传入本方法
// 包括上面的 Animal、Dog（没有实现Eat方法的Cat不行）
// 不同的animal实例可以有不同的Eat实现方式，即为多态
func Fun(animal IAnimal) {
	animal.Eat()
}

Go语言参数传递是值传递还是引用传递？

先说结论: 值传递。但却需要区分传递的参数是引用类型还是非引用类型，以及传递的参数有没有指针（包括传递的参数子元素是否包含指针）参考

• 引用类型：slice、map、channel

• 引用类型不是传引用

• make的map和channel本质上是指针类型, 如map用 make函数返回的是一个hmap类型的指针*hmap，make函数总是返回初始化后类型变量本身）

• slice本质上是结构体，其效果与结构体完全一致，函数内的操作会影响底层数组，但不会改变函数外变量的len和cap， 参考slice特性
• 自定义的Struct不是引用类型, 但若其子元素有指针类型时, 其特性将类似于slice

以显式的指针传递为例

package main
import "log"
func test(s *struct {t int}) *struct {t int} {
   // 0xc000096000 0xc00008e020
   // 按%p输出 s，表示输出指针s的值，也即指针s指向的变量内存地址
   // 按%p输出 &s，表示输出指针变量s的内存地址
   // 需要理解一下，指针的值区别于指针变量的地址
   // 指针的值是它指向的变量地址，但它本身也是一个变量，所以它自己也有一个内存地址
   // 可以看出，在外部的指针变量地址与函数内部的指针变量地址不一致
   // 指针的值是一致的，因此函数参数的传递是值传递，发生了值拷贝
   log.Printf("%p %p\n", s, &s)
   return s
}
func main() {
   s := &struct {
      t int
   }{1}
   // 0xc000096000 0xc00008e010
   log.Printf("%p %p\n", s, &s)
   test(s)
}

以slice传递为例

package main
import "log"
func modifySli(sli []int) {
	// 0xc00000c060
	//&sli已经是新的了, 说明函数是值传递(若为引用传递, 需要与调用时的地址保持一致)
	log.Printf("slice address in modifySli:%p\n", &sli)
	sli[0] = 2
}
func modifySli1(sli []int) {
	// 由于传进来的参数，cap为1，已经有了1个元素，append之后发生扩容
	sli = append(sli, 2)
	sli[0] = 1
}
func main() {
	s := make([]int, 0, 1)
	s = append(s, 1)
	// 0xc00000c040 [1]
	log.Printf("%p %+v\n", &s, s)
	modifySli(s)
	// 0xc00000c040 [2]
	// 函数调用没有传递指针, modifySli函数也成功修改了slice的数据
	log.Printf("%p %+v\n", &s, s)
	modifySli1(s)
	// 0xc00000c040 [2]
	// 在 modifySli1 中，sli发生了扩容，在该函数中sli变量拥有了新的底层数组，就影响不到外面的s了
	log.Printf("%p %+v\n", &s, s)
}

结构体和结构体指针方法调用的区别

type MyStruct struct {
    Name string
}

func (s MyStruct) SetName1(name string) {
    s.Name = name
}

func (s *MyStruct) SetName2(name string) {
    s.Name = name
}

当在一个类型上定义一个方法时，接收器（在上面的例子中是 s）的行为就像它是方法的一个参数一样。其相当于：

 func SetName1(s MyStruct, name string){
    s.Name = name
 }

 func SetName2(s *MyStruct,name string){
    s.Name = name
 }

因此结构体方法是要将接收器定义成值还是指针，这本质上与函数参数应该是值还是指针是同一个问题。很显然，如上SetName1方法修改的是对象的拷贝副本，并不能修改到原对象。虽然本质上如上所述，但还是有使用上的区别：

func TestSetName(t *testing.T) {
	m := MyStruct{}
	m.SetName2("2")
	m.SetName1("1")  // m.Name 值为 2
	m2 := &MyStruct{}
	m2.SetName2("2")
	m2.SetName1("1")  // m2.Name 值为 2
	SetName1(m, "")
	SetName2(m, "")  // 编译报错
	SetName1(m2, "")  // 编译报错
	SetName2(m2, "")
}

函数参数要求结构体还是结构体指针参数类型严格匹配，而接收器方法不要求严格匹配，编译器会自动去找对应的方法。

为支持以上特性，Go不允许接收器同时实现同一个方法的结构体和结构体指针方法，如上例子中，是不可以再实现func (s *MyStruct) SetName1(name string)的。

如何选择呢

整体有以下几个考虑因素，按重要程度顺序排列：

1. 在使用上的考虑：方法是否需要修改接收器？如果需要，接收器必须是一个指针，否则无法修改。

2. 在效率上的考虑：如果接收器很大，比如：一个大的结构体，使用指针接收器会好很多。

3. 在一致性上的考虑：如果类型的某些方法必须有指针接收器，那么其余的方法也应该有指针接收器，保持一致。

结构体结合接口使用的注意项

type Duck interface {
	SetName1(name string)
}

func TestDuck(t *testing.T) {
	var d Duck = MyStruct{}
	d.SetName1("")
	var d1 Duck = &MyStruct{}
	d1.SetName1("")
}

如上这么用都是可以的，但如果把MyStruct的SetName1修改为结构体指针方法：

func (s *MyStruct) SetName1(name string) {
	s.Name = name
}

func TestDuck(t *testing.T) {
	var d Duck = &MyStruct{}
	d.SetName1("")
	var d1 Duck = MyStruct{}  // 编译报错
	d1.SetName1("")
}

这是为什么呢？本质原因还是Go语言参数传递是值传递。

将一个指针拷贝，它们还是指向同一个地址，指向一个确定的结构体；将一个值拷贝，它们变成了两个不同的结构体，有着不同的地址。

当在一个结构体指针上，通过接口，调用一个接收者为值类型的方法时，Go 首先会创建这个指针的副本，然后将这个指针解引用，再作为接收者参数传递给该方法。这两个指针指向相同的地址

但是，当在一个值类型的结构体上，通过接口，调用一个接收者为指针类型的方法时，编译器不会无中生有创建一个新的指针，即使编译器可以创建新指针，由于Go语言参数传递是值传递，那么MyStruct{}变量在传参的时候发生值拷贝，编译器创建的这个新指针指向的也是这个新的MyStruct{}，而不是原对象。

如上两种使用场景的原理区别

在上3个小节（结构体和结构体指针方法调用的区别）中，接收器方法不要求严格匹配，编译器会自动去找对应的方法；但在结合接口使用时，值类型结构体 -> 赋值给接口 -> 调用接受者类型为指针类型的结构体方法，这种情况为什么又会编译报错呢？

因为在结构体/结构体指针方法调用时，是直接调用定义的方法；但把结构体/结构体指针赋值给interface时，是需要通过interface来调用方法的，interface需要确认该变量实例是否满足interface定义的要求，以及编译器需要确认赋值给interface之后再来调用方法时是否会破坏struct自身定义的方法功能，当struct定义的方法为结构体指针方法，那么修改接收器的时候是需要生效的，但当编译报错那种使用场景，根据原理可知是修改不了接收器的，因此就会编译报错不允许这种使用方式。

阻塞与死锁

func main() {
	go func() {
		time.Sleep(time.Minute*5)
	}()
	select{}{}
}

上面这段程序没有和有睡眠子协程为什么不一样呢？没有睡眠子协程会立即panic： fatal error: all goroutines are asleep - deadlock! ，有睡眠子协程的为啥不会呢？

因为所有协程都永久阻塞的情况程序才会panic。

浅拷贝 vs 深拷贝

浅拷贝对于值类型的话是完全拷贝一份相同的值；而对于引用类型是拷贝其地址，也就是拷贝的对象修改引用类型的变量同样会影响到源对象。

对于深拷贝，任何对象都会被完完整整的拷贝一份，拷贝对象与被拷贝对象不存在任何联系，也就不会互相影响。

如果需要拷贝的对象中没有引用类型，那么使用浅拷贝就可以了。

浅拷贝

copy

golang 内建函数func copy(dst, src []Type) int只能用于切片，不能用于 map 等任何其他类型，而且属于浅拷贝。使用copy将 src 完全 复制 到 dst:

1. 如果 dst 长度小于 src 的长度，则只会拷贝 dst 长度的 src 中的元素，超出部分直接忽略；

2. 如果大于，则全部拷贝过来，其余的空间填充该类型的默认值；

3. 如果相等，刚好不多不少 copy 过来，所以，通常dst在初始化时即指定其为src的长度。

4. copy只会执行切片最外层的值拷贝，如果切片元素装的是引用类型，则拷贝的是引用，解决方案见下文。

package main

import "fmt"

func main() {	
	src := []int{1, 2, 3, 5, 6, 7, 8}
	fmt.Println("src len:", len(src), "src:", src)
	dst := make([]int, 0)
	copy(dst, src)
	fmt.Println("dst len:", len(dst), "dst:", dst)
	dst1 := make([]int, len(src)/2 )
	copy(dst1, src)
	fmt.Println("dst1 len:", len(dst1), "dst1:", dst1)
	dst2 := make([]int, len(src))
	copy(dst2, src)
	fmt.Println("dst2 len:", len(dst2), "dst2:", dst2)
	dst3 := make([]int, len(src) + 2)
	copy(dst3, src)
	fmt.Println("dst3 len:", len(dst3), "dst3:", dst3)
}

运行结果如下：

src len: 7 src: [1 2 3 5 6 7 8]
dst len: 0 dst: []
dst1 len: 3 dst1: [1 2 3]
dst2 len: 7 dst2: [1 2 3 5 6 7 8]
dst3 len: 9 dst3: [1 2 3 5 6 7 8 0 0]

如果切片元素是引用类型如何拷贝，下面以多维数组为例：

func rightCopyMatrix() {
    matA := [][]int{
        {0, 1, 1, 0},
        {0, 1, 1, 1},
        {1, 1, 1, 0},
    }
    matB := make([][]int, len(matA))
    for i := range matA {
        matB[i] = make([]int, len(matA[i])) // 注意初始化长度
        copy(matB[i], matA[i])
    }
    fmt.Printf("%p, %p\n", matA, matA[0]) // 0xc00005c050, 0xc000018560
    fmt.Printf("%p, %p\n", matB, matB[0]) // 0xc00005c0a0, 0xc0000185c0
}

切片使用copy和等号复制的区别

1. 性能方面：copy复制会比等号复制慢。

2. 复制方式：copy复制为值复制，改变原切片的值不会影响新切片。而等号复制newSli:=sli[:]为指针复制，改变原切片或新切片都会对另一个产生影响。

深拷贝

深度拷贝可以通过序列化和反序列化来实现，也可以基于reflect包的反射机制完成，参考。