Go语言学习之5 进阶-排序、链表、二叉树、接口

本节主要内容：

1. 结构体和方法
2. 接口

1. 结构体和方法

     (1). 用来自定义复杂数据结构
     (2). struct里面可以包含多个字段（属性）
     (3). struct类型可以定义方法，注意和函数的区分
     (4). struct类型是值类型
     (5). struct类型可以嵌套
     (6). Go语言没有class类型，只有struct类型

(1). struct 声明：
     type 标识符 struct {
           field1 type
           field2 type
      }

type Student struct {
    Name string
    Age int
    Score int
}

(2). struct 中字段访问：和其他语言一样，使用点(.)

var stu Student

stu.Name = "tony"
stu.Age = 18
stu.Score=20

fmt.Printf("name=%s age=%d score=%d", stu.Name, stu.Age, stu.Score)

(3). struct定义的三种形式：
     (a) var stu Student
     (b) var stu *Student = new (Student)
     (c) var stu *Student = &Student{}

     其中b和c返回的都是指向结构体的指针，访问形式如下：
     stu.Name、stu.Age和stu.Score 或者 (*stu).Name、(*stu).Age。

package main 

import "fmt"

type Student struct {
    Name string
    Age int
    score float32
}

func main() {
    //下面定义并初始化
    var stu1 Student = Student {
        Name : "zhangsan",
        Age : 10,
        score : 99.99,
    }

    //struct定义的形式1
    var stu2 Student
    stu2.Name = "zhangsan2"
    stu2.Age = 15
    stu2.score = 99.66
    
    //struct定义的形式2
    var stu3 *Student = new(Student)
    stu3.Name = "lisi" //(*stu1).Name = "lisi"
    stu3.Age = 20  //(*stu1).Age = 20
    stu3.score = 88.88  //(*stu1).score = 88.88

    //struct定义的形式3
    var stu4 *Student = &Student{
        Name:"wangwu", 
        Age:19,  
        score:99.88,
    }

    fmt.Println(stu1)  //{zhangsan 10 99.99}
    fmt.Println(stu2)  //{zhangsan2 15 99.66}
    fmt.Println(stu3)  //&{lisi 20 88.88}
    fmt.Println(stu4)  //&{wangwu 19 99.88}
}

(4). struct的内存布局：struct中的所有字段在内存是连续的，布局如下：

package main

import "fmt"

type Student struct {
    Name  string
    Age   int
    score float32
}

func main() {
    var stu Student

    stu.Age = 18
    stu.Name = "hua"
    stu.score = 80

    var stu1 *Student = &Student{
        Age:  20,
        Name: "hua",
    }

    var stu3 = Student{
        Age:  20,
        Name: "hua",
    }
    
    fmt.Println(stu1.Name)
    fmt.Println(stu3)
    fmt.Printf("Name:%p
", &stu.Name) //Name:0xc042002720
    fmt.Printf("Age: %p
", &stu.Age)  //Age: 0xc042002730
    fmt.Printf("score:%p
", &stu.score)  //score:0xc042002738
}

(5). 链表定义
     type Student struct {
          Name string
          Next* Student
     }
    每个节点包含下一个节点的地址，这样把所有的节点串起来了，通常把链表中的第一个节点叫做链表头。

package main

import (
    "fmt"
    "math/rand"
)

type Student struct {
    Name string
    Age int 
    Score float32
    Id string
    next *Student
}

//遍历链表
func trans(p *Student) {
    for p != nil {
        fmt.Printf("name = %s, Age = %d, Score = %f, id = %s, next = %p
", p.Name, p.Age, p.Score, p.Id, p.next)
        p = p.next
    }
    fmt.Println()
}

//头部插入
func insertHead(head **Student, new_node *Student) {
    new_node.next = *head
    *head = new_node
}

//尾部插入
func insertTail(p *Student, new_node *Student) {
    for p.next != nil {
        p = p.next
    }
    p.next = new_node
}

//删除节点
func delNode(p *Student, id string) {
    var pre_node *Student = p
    for p != nil {
        if p.Id == id {
            pre_node.next = p.next
            break
        }
        pre_node = p
        p = p.next
    }
}

//当前节点后面插入
func addNode(p *Student, id string, add_node *Student) {
    for p != nil {
        if p.Id == id {
            add_node.next = p.next
            p.next = add_node
            break
        }
        p = p.next
    }
}

func checkNode(p *Student, id string) {
    for p != nil {
        if p.Id == id {
            fmt.Printf("name = %s, Age = %d, Score = %f, id = %s, next = %p
", p.Name, p.Age, p.Score, p.Id, p.next)
            return
        }
        p = p.next
    }
    fmt.Printf("Do not find id = %s
", id)
}

func main() {
    var stu1 Student = Student {
        Name:"name1",
        Age:rand.Intn(100),
        Score:rand.Float32()*100,
        Id:"000001",
    }
    trans(&stu1)

    var head *Student = &stu1

    var stu2 Student = Student {
        Name:"name2",
        Age:rand.Intn(100),
        Score:rand.Float32()*100,
        Id:"000002",
    }
    insertHead(&head, &stu2)  //头部插入
    trans(head)

    var stu3 Student = Student {
        Name:"name3",
        Age:rand.Intn(100),
        Score:rand.Float32()*100,
        Id:"000003",
    }

    insertTail(head, &stu3)  //尾部插入
    trans(head)

    for i := 4; i < 10 ; i++ {
        stu := Student {
            Name:fmt.Sprintf("name%d", i),
            Age:rand.Intn(100),
            Score:rand.Float32()*100,
            Id:fmt.Sprintf("00000%d", i),
        }

        addNode(head, "000003", &stu)  //增加节点
    }
    trans(head)

    delNode(head, "000005")  //删除节点
    trans(head)

    checkNode(head, "000006") //查
    checkNode(head, "0000010")
}

(6). 双链表定义
     type Student struct {
          Name string
          Next* Student
          Prev* Student
     }
    如果有两个指针分别指向前一个节点和后一个节点，我们叫做双链表

(7). 二叉树定义
     type Student struct {
          Name string
          left* Student
          right* Student
     }
    如果每个节点有两个指针分别用来指向左子树和右子树，我们把这样的结构叫做二叉树

package main

import "fmt"

type Student struct {
    Name  string
    Age   int
    Score float32
    left  *Student
    right *Student
}

func trans(root *Student) {
    if root == nil {
        return
    }
    fmt.Println(root)

    trans(root.left)
    trans(root.right)

}

func main() {
    var root *Student = new(Student)

    root.Name = "stu01"
    root.Age = 18
    root.Score = 100

    var left1 *Student = new(Student)
    left1.Name = "stu02"
    left1.Age = 18
    left1.Score = 100

    root.left = left1

    var right1 *Student = new(Student)
    right1.Name = "stu04"
    right1.Age = 18
    right1.Score = 100

    root.right = right1

    var left2 *Student = new(Student)
    left2.Name = "stu03"
    left2.Age = 18
    left2.Score = 100

    left1.left = left2

    trans(root)
}

(8). 结构体是用户单独定义的类型，不能和其他类型进行强制转换

package main 

func main() {
    type Student struct {
        Number int
    }

    type Stu Student //alias

    var a Student
    a.Number = 10

    var b Stu
    a = b // cannot use b (type Stu) as type Student in assignment
}

package main

import "fmt"

type integer int

type Student struct {
    Number int
}

type Stu Student //alias

func main() {

    var i integer = 1000
    var j int = 100

    // j = i  //cannot use i (type integer) as type int in assignment
    j = int(i)  //进行强制转换  ok
    fmt.Println(j)

    var a Student
    a = Student{30}

    var b Stu
    a = Student(b)  //进行强制转换  ok
    fmt.Println(a)  //{0}
}

(9).(工厂模式) golang中的struct没有构造函数，一般可以使用工厂模式来解决这个问题

package main 

import "fmt"

type student struct {
    Name string
    Age int
}

func NewStudent(name string, age int) *student {
    return &student{
        Name:name,
        Age:age,
    }
}

func main() {
    s := new (student)
    s = NewStudent("tony", 20)
    fmt.Println(s) //&{tony 20}
}

(10). 再次强调
     a). make 用来创建map、slice、channel
     b). new用来创建值类型

(11). (struct中的tag) 我们可以为struct中的每个字段，写上一个tag。这个tag可以通过反射的机制获取到，最常用的场景就是json序列化和反序列化
     type student struct {
            Name stirng "this is name field"
            Age int "this is age field"
      }

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string `json:"student_name"`
    Age   int    `json:"age"`
    Score int    `json:"score"`
}

type Student2 struct {
    name  string
    age   int
    score int
}

func main() {
    var stu Student = Student{
        Name:  "stu01",
        Age:   18,
        Score: 80,
    }

    data, err := json.Marshal(stu)
    if err != nil {
        fmt.Println("json encode stu failed, err:", err)
        return
    }

    fmt.Println(string(data))  //{"student_name":"stu01","age":18,"score":80}

    var stu2 Student2 = Student2{
        name:  "stu02",
        age:   20,
        score: 90,
    }

    data2, err2 := json.Marshal(stu2)
    if err2 != nil {
        fmt.Println("json encode stu failed, err:", err2)
        return
    }

    fmt.Println(string(data2))  // {}  由于结构体成员变量首字母小写，在json序列化时对外不可见，因此为空。改为首字母大写就OK
}

(12). (匿名字段)结构体中字段可以没有名字，即匿名字段
      type Car struct {
            Name string
            Age int
      }

      type Train struct {
           Car
           Start time.Time
           int
      }

package main

import (
    "fmt"
    "time"
)

type Car struct {
    Name string
    Age int 
}

type Train struct {
    Car
    Start time.Time
    int
}

func main() {
    var t Train
    
    //如果没有命名冲突可以直接这样访问
    //t.Name = "demo"
    //t.Age = 20
    
    t.Car.Name = "demo"
    t.Car.Age = 20
    t.int = 100

    fmt.Println(t) //{{demo 20} 0001-01-01 00:00:00 +0000 UTC 100}
}

(13). 匿名字段冲突处理

package main

import (
    "fmt"
)

type Cart1 struct {
    name string
    age  int
}

type Cart2 struct {
    name string
    age  int
}

type Train struct {
    Cart1
    Cart2
}

func main() {
    var t Train

    // t.name = "train"
    // t.age = 100

    // fmt.Println(t) //ambiguous selector t.name
    
    t.Cart1.name = "train1"
    t.Cart1.age = 100

    t.Cart2.name = "train2"
    t.Cart2.age = 200

    fmt.Println(t) //{{train1 100} {train2 200}}
}

 (14). 方法

        a. 方法定义

            方法其实就是一个函数，在 func 这个关键字和方法名中间加入了一个特殊的接收器类型。接收器可以是结构体类型或者是非结构体类型。接收器是可以在方法的内部访问的。

             Golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是struct。

             定义：func (recevier type) methodName(参数列表)(返回值列表) {}

package main 

import "fmt"

type Student struct {
    Name string
    Age int
}

//为结构体Student定义init方法
func (p *Student) init(name string, age int) {
    p.Name = name
    p.Age = age
}

func main() {
    var stu Student
    stu.init("zhansan", 20)
    fmt.Printf("name = %s, age = %d
", stu.Name, stu.Age) //name = zhansan, age = 20
}

"类的"方法:
        Go 语言不像其它面相对象语言一样可以写个类，然后在类里面写一堆方法，但其实Go语言的方法很巧妙的实现了这种效果：我们只需要在普通函数前面加个接受者（receiver，写在函数名前面的括号里面），这样编译器就知道这个函数（方法）属于哪个struct了。

1). 在 Go 中，（接收者）类型关联的方法不写在类型结构里面，就像类那样；耦合更加宽松；类型和方法之间的关联由接收者来建立。
2). 方法没有和数据定义（结构体）混在一起：它们是正交的类型；表示（数据）和行为（方法）是独立的。

注意：Go语言不允许为简单的内置类型添加方法，所以下面定义的方法是非法的。

package main

//cannot define new methods on non-local type int
func (a int) add(b int) {
}

func main() {

}

package main

import(
  "fmt"
)

//将int定义别名myInt
type myInt int
 
func Add(a ,b int) int {             //函数
    return a + b
}

//cannot define new methods on non-local type int
// func (a int) Add(b int) {
// }

//对myInt类型定义Add方法
func (a myInt) Add (b myInt) myInt {   //方法
    return a + b
}
 
func main() {
    a, b := 3,4
    var aa, bb myInt = 3, 4
    fmt.Println(Add(a, b)) //7
    fmt.Println(aa.Add(bb))  //7
}

        b. 方法的调用

package main

import "fmt"

type A struct {
    a int
}

func (this A) test() {
    fmt.Println(this.a)
}

func main() {
    var t A
    t.a = 100
    t.test() //100
}

        c. 方法和函数的区别
           函数调用： function(variable, 参数列表)
           方法：variable.function(参数列表)

        为什么我们已经有函数了还需要方法呢？

        I). Go 不是纯粹的面向对象编程语言，而且Go不支持类。因此，基于类型的方法是一种实现和类相似行为的途径。
        II). 相同的名字的方法可以定义在不同的类型上，而相同名字的函数是不被允许的。

package main

import "fmt"

type People struct {
    Age int
}

type Animal struct {
    Age int
}

func (p People) Eat() {
    fmt.Println("People age is ", p.Age)
}

func (a Animal) Eat() {
    fmt.Println("Animal age is ", a.Age)
}

func main() {
    var p People = People {
        Age:20,
    }

    var a Animal = Animal {
        Age:2,
    }

    p.Eat()
    a.Eat()
}

       d. 指针接收器与值接收器

        本质上和函数的值传递和地址传递是一样的。

        在上面的例子中，我们只使用值接收器的方法。还可以创建使用指针接收器的方法。值接收器和指针接收器之间的区别在于，在指针接收器的方法内部的改变对于调用者是可见的，然而值接收器的情况不是这样的。

#include<stdio.h>

void set(int *s, int newValue)
{
    *s = newValue;
}

int main()
{
    int num = 1;
    printf("before num = %d
", num);  //before num = 1
    set(&num, 10);
    printf("after num = %d
", num);  //after num = 10
}

package main

import "fmt"

type People struct {
    Name string
    Age int
}

func (p People) ChangeAge(age int) {
    p.Age = age
}

func (p *People) ChangeName(name string) {
    p.Name = name
}

func main() {
    var p People = People {
        Name:"zhangsan",
        Age:20,
    }
    
    fmt.Printf("before name = %s, age = %d
", p.Name, p.Age) //before name = zhangsan, age = 20
    // (&p).ChangeName("lisi")   //OK
    p.ChangeName("lisi") //p.ChangeName("lisi") 自动被Go语言解释为 (&p).ChangeName("lisi")
    p.ChangeAge(10)
    fmt.Printf("after name = %s, age = %d
", p.Name, p.Age) //after name = lisi, age = 20
}

       那么什么时候使用指针接收器，什么时候使用值接收器？
        一般来说，指针接收器可以使用在：对方法内部的接收器所做的改变应该对调用者可见时。
指针接收器也可以被使用在如下场景：
      1. 当拷贝一个结构体的代价过于昂贵时。
          考虑下一个结构体有很多的字段。在方法内使用这个结构体做为值接收器需要拷贝整个结构体，这是很昂贵的。在这种情况下使用指针接收器，结构体不会被拷贝，只会传递一个指针到方法内部使用。
      2. 在其他的所有情况，值接收器都可以被使用。

      e. 在方法中使用值接收器 与 在函数中使用值参数

      i) 当一个函数有一个值参数，它只能接受一个值参数。

      ii) 当一个方法有一个值接收器，它可以接受值接收器和指针接收器。

      iii) 当一个方法有一个指针接收器，它可以接受值接收器和指针接收器。

package main

import "fmt"

type Car struct {
    weight int
    name   string
}

func InitChange(p Car) {
    p.name = "func"
    p.weight = 200
}

//值接收器
func (p Car) InitChange() {
    p.name = "receiver"
    p.weight = 600
    
}

//指针接收器
func (p *Car) InitChange2() {
    p.name = "receiver2"
    p.weight = 800
    
}

func main() {
    var c Car = Car{
        weight:100,
        name:"bike",
    }
    
    p := &c
    
    // Run(&c) // cannot use p (type *Car) as type Car in argument to Run
    InitChange(c)  //传值
    fmt.Println(c, " running in the func") //{200 bike}  running in the func
    
    // c.Run()
    // 为了方便Go语言把 p.Run() 解释为 (*p).Run()，因此在Run中改变值不起作用
    p.InitChange()  //{100 receiver}  running int the receiver
    fmt.Println(c, " running in the receiver") //{100 bike}  running in the receiver

    // 为了方便Go语言把 c.Run() 解释为 (&c).Run()，因此在Change中改变值起作用
    // c.InitChange2()  //传值
    p.InitChange2()  //传指针
    fmt.Println(c, " running in the receiver2") //{800 receiver2}  running in the Change
}

      f. 匿名字段的方法

       属于结构体的匿名字段的方法可以被直接调用，就好像这些方法是属于定义了匿名字段的结构体一样。

package main

import "fmt"

type Car struct {
    weight int
    name   string
}

func (p Car) Run() {
    fmt.Println("running")
}

//Bike不仅继承了Car的成员变量weight和name，同时继承了Run方法
type Bike struct {
    Car //匿名字段
    wheel int
}

func main() {
    var b Bike = Bike {
        Car: Car{
            weight:100,
            name:"bike",
        },
        wheel:2,
    }
    

    fmt.Println(b) //{{100 bike} 2}
    b.Run() //running 匿名字段方法 Run 
}

      g. 方法的访问控制，通过大小写控制

      在不同的包之间，方法要对外可见需要首字母大写。

      h. 继承

      如果一个struct嵌套了另一个匿名结构体，那么这个结构可以直接访问匿名结构体的方法，从而实现了继承。

package main

import "fmt"

type Car struct {
    weight int
    name   string
}

func (p Car) Run() {
    fmt.Println("running")
}

//Bike不仅继承了Car的成员变量weight和name，同时继承了Run方法
type Bike struct {
    Car
    wheel int
}

func main() {
    var a Bike
    a.weight = 100
    a.name = "bike"
    a.wheel = 2

    fmt.Println(a) //{{100 bike} 2}
    a.Run() //running
}

      i. 组合和匿名字段

      如果一个struct嵌套了另一个有名结构体，那么这个模式就叫组合。

      go里面的继承是通过组合来实现的。
      匿名字段是一个特殊的组合。

package main

import "fmt"

type Car struct {
    weight int
    name   string
}

func (p Car) Run() {
    fmt.Println("running")
}

type Bike struct {
    Car
    lunzi int
}

type Train struct {
    c Car  //组合
}

func main() {
    var a Bike
    a.weight = 100
    a.name = "bike"
    a.lunzi = 2

    fmt.Println(a)
    a.Run()

    var b Train
    //注意访问方式
    b.c.weight = 100
    b.c.name = "train"
    b.c.Run()
}

      j. 多重继承

      如果一个struct嵌套了多个匿名结构体，那么这个结构可以直接访问多个匿名结构体的方法，从而实现了多重继承。

package main

import "fmt"

type People struct {
    Name string
    Age  int
}

type Animal struct {
    Place  string
    Weight   int
}

func (p People) Eat() {
    fmt.Println("People eat food")
}

func (p People) Sleep() {
    fmt.Println("People sleep")
}

func (p Animal) Eat() {
    fmt.Println("Animal sleep")
}

func (p Animal) Run() {
    fmt.Println("Animal running")
}

func (p Animal) Cry() {
    fmt.Println("Animal cry")
}

//Test继承了People和Animal里面的成员变量和方法
type Test struct {
    People
    Animal
}

func main() {
    var t Test
    t.Name = "sara"
    t.Age = 20

    t.Place = "xian"
    t.Weight = 200

    // t.Eat()  //ambiguous selector t.Eat
    t.People.Eat()
    t.Animal.Eat()

    t.Sleep()  //t.People.Sleep()
    t.Run() //t.Animal.Run() 
    t.Cry() //t.Animal.Cry() 
}

2. 接口

什么是接口？
       在面向对象的领域里，接口一般这样定义：接口定义一个对象的行为。接口只指定了对象应该做什么，至于如何实现这个行为（即实现细节），则由对象本身去确定。

       在 Go 语言中，接口就是方法签名（Method Signature）的集合。当一个类型定义了接口中的所有方法，我们称它实现了该接口。这与面向对象编程（OOP）的说法很类似。接口指定了一个类型应该具有的方法，并由该类型决定如何实现这些方法。

(1). 定义
      Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。
      type example interface{

             Method1(参数列表) 返回值列表
             Method2(参数列表) 返回值列表
             …
      }

package main

import "fmt"

type People struct {
    name string
    age  int
}

type Test interface {
    Eat()
    Sleep()
}

func (p People) Eat() {
    fmt.Println("people eat")
}

func (p People) Sleep() {
    fmt.Println("people sleep")
}

func main() {

    var t Test
    fmt.Println(t) //<nil>

    var people People = People {
        name: "people",
        age:  100,
    }

    t = people
    t.Eat()
    t.Sleep()

    fmt.Println("t:", t)  //t: {people 100}
}

(2). interface类型默认是一个指针
     如(1)中的例子var t Test    fmt.Println(t) //<nil>

(3). 接口的内部表示

     我们可以把接口看作内部的一个元组 (type, value)。 type 是接口底层的具体类型（Concrete Type），而 value 是具体类型的值。

package main

import (  
    "fmt"
)

type Test interface {  
    Tester()
}

type MyFloat float64

func (m MyFloat) Tester() {  
    fmt.Println(m)
}

func describe(t Test) {  
    fmt.Printf("Interface type %T value %v
", t, t)
}

func main() {  
    var t Test
    f := MyFloat(89.7)
    t = f
    describe(t)  //Interface type main.MyFloat value 89.7
    t.Tester()  //89.7
}

(4). 接口实现
     a. Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，golang中没有implement
类似的关键字。
     b. 如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口。

package main

import "fmt"

type People struct {
    name string
    age  int
}

type EatInter interface {
    Eat()
}

type SleepInter interface {
    Sleep()
}

func (p People) Eat() {
    fmt.Println("people eat")
}

func (p People) Sleep() {
    fmt.Println("people sleep")
}

func main() {
    var e EatInter
    var s SleepInter

    var people People = People {
        name: "people",
        age:  100,
    }

    //people实现了EatInter和SleepInter接口
    e = people
    s = people
    e.Eat()
    s.Sleep()

    fmt.Println("e:", e)  //e: {people 100}
    fmt.Println("s:", s)  //s: {people 100}
}

     c. 如果一个变量只含有了1个interface的部分方法，那么这个变量没有实现这个接口。

(5). 多态
     一种事物的多种形态，都可以按照统一的接口进行操作。

package main

import "fmt"

//一个接口Test，方法Eat()和Sleep()多种实现（People和Animal），这就是多态
type Test interface {
    Eat()
    Sleep()
}

type People struct {
    Name string
}

type Animal struct {
    Name  string
}

func (p People) Eat() {
    fmt.Printf("People %s eat
", p.Name)
}

func (p People) Sleep() {
    fmt.Printf("People %s sleep
", p.Name)
}

func (p Animal) Eat() {
    fmt.Printf("Animal %s eat
", p.Name)
}

func (p Animal) Sleep() {
    fmt.Printf("Animal %s sleep
", p.Name)
}

func main() {

    var t Test

    var a Animal = Animal {
        Name:  "Cat",
    }

    t = a
    t.Eat()
    t.Sleep()
    fmt.Println("t:", t)

    var p People = People {
        Name: "people",
    }

    t = p
    t.Eat()
    t.Sleep()
    fmt.Println("t:", t)
}

    练习：调用Sort系统函数实现对自定义数组的排序

package main

import (
    "fmt"
    "math/rand"
    "sort"
)

type Student struct {
    Name     string
    Id       string
    Age      int
    sortType int
}

type Book struct {
    Name   string
    Author string
}

//官网的Sort没有实现对任意类型的排序，为了实现对StudentArray数组的排序，
//查询官网发现Sort的定义，参数的是一个接口，该接口中只要实现Len，Less，Swap三个方法就可以调用Sort函数
// func Sort(data Interface)
// type Interface interface {
//        Len() int
//        Less(i, j int) bool
//        Swap(i, j int)
// }

type StudentArray []Student

func (p StudentArray) Len() int {
    return len(p)
}

func (p StudentArray) Less(i, j int) bool {
    return p[i].Name < p[j].Name  //对名字桉升序排列
}

func (p StudentArray) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

func main() {
    var stus StudentArray
    for i := 0; i < 10; i++ {
        stu := Student{
            Name: fmt.Sprintf("stu%d", rand.Intn(100)),
            Id:   fmt.Sprintf("110%d", rand.Int()),
            Age:  rand.Intn(100),
        }

        stus = append(stus, stu)
    }

    for _, v := range stus {
        fmt.Println(v)
    }

    fmt.Println("

")

    sort.Sort(stus)
    for _, v := range stus {
        fmt.Println(v)
    }
}

(6). 接口嵌套
     一个接口可以嵌套在另外的接口，如下所示：

     type ReadWrite interface {
             Read(b Buffer) bool
             Write(b Buffer) bool
     }
     type Lock interface {
             Lock()
             Unlock()
     }
     type Close interface {
             Close()
     }
     type File interface {
             ReadWrite
             Lock
            Close
     }

package main

import "fmt"

type Reader interface {
    Read()
}

type Writer interface {
    Write()
}

//接口嵌套
type ReadWriter interface {
    Reader
    Writer
}

type File struct {
}

func (f *File) Read() {
    fmt.Println("read data")
}

func (f *File) Write() {
    fmt.Println("write data")
}

func Test(rw ReadWriter) {
    rw.Read()
    rw.Write()
}

func main() {
    var f *File
    var b interface{}
    b = f
    // Test(f)
    v, ok := b.(ReadWriter) //f中实现了Reader和Writer接口，因此ok为true
    fmt.Println(v, ok) //<nil> true
}

(7). 类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型，可以采用以下方法进行转换：
     var t int
     var x interface{}
     x = t
     y = x.(int) //转成int

     var t int
     var x interface{}
     x = t
     y, ok = x.(int) //转成int，带检查。y为x的值

类型断言用于提取接口的底层值（Underlying Value）。
在语法 i.(T) 中，接口 i 的具体类型是 T，该语法用于获得接口的底层值。

package main

import (  
    "fmt"
)

func assert(i interface{}) {  
    // s := i.(int)
    if v, ok := i.(int); ok { //此时当传入assert(s)时程序不会panic
        fmt.Println(v)
    }
}
func main() {  
    var s interface{} = 56
    assert(s)

    s = "hello"
    assert(s) //panic: interface conversion: interface {} is string, not int
}

注意：v, ok := i.(T)
          如果 i 的具体类型是 T，那么 v 赋值为 i 的底层值，而 ok 赋值为 true。
          如果 i 的具体类型不是 T，那么 ok 赋值为 false，v 赋值为 T 类型的零值，此时程序不会报错。

(8). 类型断言，采用type switch方式

     类型选择用于将接口的具体类型与很多 case 语句所指定的类型进行比较。它与一般的 switch 语句类似。唯一的区别在于类型选择指定的是类型，而一般的 switch 指定的是值。
     类型选择的语法类似于类型断言。类型断言的语法是 i.(T)，而对于类型选择，类型 T 由关键字 type 代替。

     练习，写一个函数判断传入参数的类型

func classifier(items ...interface{}) {
    for i, x := range items { 
    switch x.(type) {
        case bool: fmt.Printf("param #%d is a bool
", i)
        case float64: fmt.Printf("param #%d is a float64
", i)
        case int, int64: fmt.Printf("param #%d is an int
", i)
        case nil: fmt.Printf("param #%d is nil
", i)
        case string: fmt.Printf("param #%d is a string
", i)
        default: fmt.Printf("param #%d’s type is unknown
", i)
    }
}

package main

import "fmt"

type Student struct {
    Name string
    Sex  string
}

func Test(a interface{}) {
    b, ok := a.(Student)
    if ok == false {
        fmt.Println("convert failed")
        return
    }
    //b += 3
    fmt.Println(b)
}

func just(items ...interface{}) {
    for index, v := range items {
        switch v.(type) {
        case bool:
            fmt.Printf("%d params is bool, value is %v
", index, v)
        case int, int64, int32:
            fmt.Printf("%d params is int, value is %v
", index, v)
        case float32, float64:
            fmt.Printf("%d params is float, value is %v
", index, v)
        case string:
            fmt.Printf("%d params is string, value is %v
", index, v)
        case Student:
            fmt.Printf("%d params student, value is %v
", index, v)
        case *Student:
            fmt.Printf("%d params *student, value is %v
", index, v)
        }
    }
}

func main() {
    var b Student = Student{
        Name: "stu01",
        Sex:  "female",
    }
    Test(b)
    just(28, 8.2, "this is a test", b, &b)
}

      还可以将一个类型和接口相比较。如果一个类型实现了接口，那么该类型与其实现的接口就可以互相比较。

package main

import "fmt"

type Describer interface {  
    Describe()
}
type Person struct {  
    name string
    age  int
}

func (p Person) Describe() {  
    fmt.Printf("%s is %d years old", p.name, p.age)
}

func findType(i interface{}) {  
    switch v := i.(type) {
    case Describer:
        v.Describe()
    default:
        fmt.Printf("unknown type
")
    }
}

func main() {  
    findType("zhangsan")  //unknown type
    p := Person{
        name: "zhangsan",
        age:  25,
    }
    findType(p)  //zhangsan is 25 years old
}

 (9). 空接口，Interface{}
      空接口没有任何方法，所以所有类型都实现了空接口。
      var a int
      var b interface{}  //空接口
      b = a

package main

import (  
    "fmt"
)

func describe(i interface{}) {  
    fmt.Printf("Type = %T, value = %v
", i, i)
}

func main() {  
    s := "Hello World"
    describe(s) //Type = string, value = Hello World
    i := 20
    describe(i)  //Type = int, value = 20
    strt := struct {
        name string
    }{
        name: "zhangsan",
    }
    describe(strt) //Type = struct { name string }, value = {zhangsan}
}

(10). 判断一个变量是否实现了指定接口

package main

import "fmt"

type Describer interface {  
    Describe() string
}

type Person struct {  
    Name string
    Age  int
}

func (p Person) Describe() string {  
    str := fmt.Sprintf("%s is %d years old", p.Name, p.Age)
    return str
}

func findType(a interface{}) {
    if v, ok := a.(Describer); ok {
        fmt.Printf("v implements Describer(): %s
", v.Describe())
    }
}

func main() {
    p := Person {
        Name: "zhangsan",
        Age:  25,
    }

    findType(p) //v implements Describer(): zhangsan is 25 years old
}

(11). 指针类型和值类型的区别

package main

import "fmt"

type Describer interface {  
    Describe()
}
type Person struct {  
    name string
    age  int
}

func (p Person) Describe() { // 使用值接受者实现  
    fmt.Printf("%s is %d years old
", p.name, p.age)
}

type Address struct {
    state   string
    country string
}

func (a *Address) Describe() { // 使用指针接受者实现
    fmt.Printf("State %s Country %s", a.state, a.country)
}

// func (a Address) Describe() { // 使用指针接受者实现
//     fmt.Printf("State %s Country %s", a.state, a.country)
// }

func main() {  
    var d1 Describer
    p1 := Person{"Sam", 25}
    d1 = p1
    d1.Describe()
    p2 := Person{"James", 32}
    d1 = &p2
    d1.Describe()

    var d2 Describer
    a := Address{"Washington", "USA"}

    /* cannot use a (type Address) as type Describer
       in assignment: Address does not implement
       Describer (Describe method has pointer
       receiver)
    */
   
   //出错原因其原因是：对于使用指针接受者的方法，用一个指针或者一个可取得地址的值来调用
   //都是合法的。但接口中存储的具体值（Concrete Value）并不能取到地址，因此在第 47 行，
   //对于编译器无法自动获取 a 的地址，于是程序报错。
    // d2 = a //error 但是如果将22-24替换为26-28，则d2 = a和d2 = &a都可以

    d2 = &a // OK
    
    d2.Describe()

}

(12). 变量slice和接口slice之间赋值操作，for range 

var a []int
var b []interface{}
b = a

(13). 接口的零值

    接口的零值是 nil。对于值为 nil 的接口，其底层值（Underlying Value）和具体类型（Concrete Type）都为 nil。

    对于值为 nil 的接口，由于没有底层值和具体类型，当我们试图调用它的方法时，程序会产生 panic 异常。

package main

import "fmt"

type Describer interface {  
    Describe()
}

func main() {  
    var d1 Describer
    if d1 == nil {
        fmt.Printf("d1 is nil and has type %T value %v
", d1, d1)
    }
    
    //d1.Describe() //panic: runtime error: invalid memory address or nil pointer dereference
}

练习：实现一个通用的链表类（待完善）

package main

import "fmt"

type LinkNode struct {
    data interface{}
    next *LinkNode
}

type Link struct {
    head *LinkNode
    tail *LinkNode
}

func (p *Link) InsertHead(data interface{}) {
    node := &LinkNode{
        data: data,
        next: nil,
    }

    if p.tail == nil && p.head == nil {
        p.tail = node
        p.head = node
        return
    }

    node.next = p.head
    p.head = node
}

func (p *Link) InsertTail(data interface{}) {
    node := &LinkNode{
        data: data,
        next: nil,
    }

    if p.tail == nil && p.head == nil {
        p.tail = node
        p.head = node
        return
    }

    p.tail.next = node
    p.tail = node
}

func (p *Link) Trans() {
    q := p.head
    for q != nil {
        fmt.Println(q.data)
        q = q.next
    }
}

package main

import "fmt"

func main() {

    var link Link
    for i := 0; i < 10; i++ {
        //intLink.InsertHead(i)
        link.InsertTail(fmt.Sprintf("str %d", i))
    }

    link.Trans()
}

通过下面的例子体会接口的作用：

package main

import (  
    "fmt"
)

type SalaryCalculator interface {  
    CalculateSalary() int
}

type Permanent struct {  
    empId    int
    basicpay int
    pf       int
}

type Contract struct {  
    empId  int
    basicpay int
}

//salary of permanent employee is sum of basic pay and pf
func (p Permanent) CalculateSalary() int {  
    return p.basicpay + p.pf
}

//salary of contract employee is the basic pay alone
func (c Contract) CalculateSalary() int {  
    return c.basicpay
}

/*
total expense is calculated by iterating though the SalaryCalculator slice and summing  
the salaries of the individual employees  
*/
func totalExpense(s []SalaryCalculator) {  
    expense := 0
    for _, v := range s {
        expense = expense + v.CalculateSalary()
    }
    fmt.Printf("Total Expense Per Month $%d", expense)
}

func main() {  
    pemp1 := Permanent{1, 5000, 20}
    pemp2 := Permanent{2, 6000, 30}
    cemp1 := Contract{3, 3000}
    employees := []SalaryCalculator{pemp1, pemp2, cemp1}
    totalExpense(employees)

}

//假如公司增加了一种新的员工类型 Freelancer，它有着不同的薪资结构。Freelancer只需传递到 totalExpense 的切片参数中，无需 totalExpense 方法本身进行修改。只要 Freelancer 也实现了 SalaryCalculator 接口，totalExpense 就能够实现其功能。

用go实现一个图书管理系统：
    1. 实现一个图书管理系统，具有以下功能：
        a. 书籍录入功能，书籍信息包括书名、副本数、作者、出版日期
        b. 书籍查询功能，按照书名、作者、出版日期等条件检索
        c. 学生信息管理功能，管理每个学生的姓名、年级、身份证、性别、借了什么书等信息
        d. 借书功能，学生可以查询想要的书籍，进行借出
        e. 书籍管理功能，可以看到每种书被哪些人借出了

参考文献：

• https://blog.csdn.net/zyc88888/article/details/80307008 （Go 方法与函数区别）
• https://studygolang.com/articles/12266 （Go 系列教程 - 接口）
• https://studygolang.com/articles/12264 （Go 系列教程）