Golang interface接口

一.interface接口

package student

import (
    "fmt"
)

/*
接口:

    1.接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量
    2.接口中所有的方法都没有方法体,即没有实现方法
    3.必须将接口的所有方法实现,才算实现了该接口.
    4.实现了接口的结构体变量,才能将该变量赋值给接口
    5.只要是数据类型都可以实现接口(不仅仅是结构体类型)
    6.一个类型可以实现多个接口
    7.Golang接口中不像Java C++的接口..Golang接口中只能有未实现的方法,不能定义变量或常量...
    8.一个接口可以继承其他一个或多个接口.但其他继承来的接口方法不允许重名,不然编译报错
    9.interface类型变量,默认是一个指针,如果没有初始化的话就是nil
*/
type Stu struct {
    Name string
}

type Test interface {
    Test() bool
    Test1() bool
}

type Say interface {
    Say()
}

type Hello interface {
    Print1()
    Say()
}

func (self *Stu) Test() bool {
    self.Name = "Tom"
    fmt.Println(self.Name, "考试通过!")
    return true
}

func (self Stu) Test1() bool { // 这里的self接受器必须和Test()中的一致.如果不一致接口赋值初始化的时候必须用变量地址去赋值

    fmt.Println(self.Name, "考试通过1!")
    return true
}

func (self Stu) Say() {
    fmt.Println("Hello ", self.Name)
}

func (self Stu) Print1() {
    fmt.Println("Print1")
}

// 将接口变量还原成  原类型变量
func TestType() {
    stu := Stu{"Mary"}
    var t1 Test = &stu // Test是接口
    // 如果你需要将接口变量,转换原来的类型
    var s2 *Stu = t1.(*Stu) // 这里如果报错的话就会断言终止程序
    fmt.Println(s2.Name)
    // 另外一种转回原来变量
    if s3, ok := t1.(*Stu); ok {
        fmt.Printf("s3的类型是:%T, s3的值是:%v \n", *s3, *s3)
        fmt.Println("convert 成功!")
    } else {
        fmt.Println("convert 失败!")
    }
}

// 主动获取接口类型
func TestGetInterfaceObj(items ...interface{}) {
    for index, obj := range items {
        index++
        switch obj.(type) {
        case int:
            fmt.Printf("第%v个参数是 int, 值是:%v \n", index, obj)
        case float64:
            fmt.Printf("第%v个参数是 float64, 值是:%v \n", index, obj)
        case Stu, *Stu:
            fmt.Printf("第%v个参数是 Stu, 值是:%v \n", index, obj)
        default:
            fmt.Printf("第%v个参数是 未知, 值是:%v \n", index, obj)

        }
    }
}

func TestInterface() {

    stu := Stu{"Mary"}
    var t1 Test = &stu // 注意!! Test实现的时候用的结构体指针,所以需要用地址去赋值调用
    var s1 Say = stu
    var h1 Hello = &stu // 只要实现了接口中的方法就能使用. Say()是Hello接口和Say接口都需要实现的方法
    t1.Test()
    t1.Test1()
    s1.Say()
    h1.Print1()
    TestType()
    var i1 int = 10
    var f1 float64 = 1.1
    TestGetInterfaceObj(i1, s1, f1, t1)
}

二.利用接口实现堆排序

package student

import (
    "fmt"
    "math/rand"
)

type StuSlice []student

type SortData interface {
    Less(i, j int) bool
}

// 堆排序:二叉树,大小堆.步骤:1.建堆 2.堆顶与堆尾交换固定堆尾  3.继续重复做建堆

func heapify(arr1 StuSlice, n int, i int) {
    maxIndex := n - 1
    c1 := (i * 2) + 1
    c2 := c1 + 1
    if c1 > maxIndex {
        return
    }

    // if arr1[i] < arr1[c1] {
    if arr1.Less(i, c1) {
        // tem := arr1[i]
        // arr1[i] = arr1[c1]
        // arr1[c1] = tem
        arr1[i], arr1[c1] = arr1[c1], arr1[i]
        heapify(arr1, n, c1)
    }
    // if (c2 <= maxIndex) && (arr1[i] < arr1[c2]) {
    if (c2 <= maxIndex) && arr1.Less(i, c2) {
        // tem := arr1[i]
        // arr1[i] = arr1[c2]
        // arr1[c2] = tem
        arr1[i], arr1[c2] = arr1[c2], arr1[i]
        heapify(arr1, n, c1)
    }

}
func buildHeap(arr1 StuSlice) {
    if len(arr1) < 2 {
        return
    }
    maxIndex := len(arr1) - 1
    heapIndex := (maxIndex - 1) / 2

    for i := heapIndex; i >= 0; i-- {
        heapify(arr1, len(arr1), i)
    }
}
func HeapSort(arr1 StuSlice) {
    buildHeap(arr1)
    // fmt.Println("buildHeap=", arr1)
    for i := len(arr1) - 1; i > 0; i-- {

        arr1[i], arr1[0] = arr1[0], arr1[i]
        // tem := arr1[i]
        // arr1[i] = arr1[0]
        // arr1[0] = tem
        heapify(arr1, i, 0)
    }
    // fmt.Println("buildHeap=", arr1)
}

func (self *StuSlice) Less(i, j int) bool {
    return ((*self)[i].Age > (*self)[j].Age)
}

func TestSort() {
    var arr StuSlice = make([]student, 10)
    for i := 0; i < len(arr); i++ {
        arr[i].score = int16(rand.Intn(10))
        arr[i].Age = int8(rand.Intn(100))
        arr[i].ClassID = "七年级(3)班"
        arr[i].Name = fmt.Sprintf("Jerry%v", i)
    }
    HeapSort(arr)
    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i])
    }

}