16.Go言語オブジェクト指向プログラミング・アプリケーション・インターフェース（C）

main.go

// Go语言·面向对象编程应用·接口
package main

//  包的本质是创建不同的文件夹
//  go的每一个文件都是属于一个包的
//  go以包的形式管理项目和文件目录。
//  import "包的路径"
import (
    model "day23/model"
    "fmt"
    "sort"
    "math/rand"
)

var content string = `
————————————————Go语言·面向对象编程应用·接口————————————————————
一、接口 interface 最佳实践

二、继承和接口
    1.当结构体A继承咯结构体B，那么A结构体就自动的继承咯B结构体的字段和方法，
    并且可以直接使用。
    2.当A结构体需要扩展功能，同时不希望破坏原来的继承关系，则可以去实现某个
    接口即可，
    因此：实现接口是对继承机制的补充。
    3.继承和接口解决的问题不同：
        继承的价值：解决代码的复用性和可维护性
        接口的价值：设计，设计好各种规范（方法），让其他自定义类型去实现这些方法。
    4.接口比继承更加灵活：
        继承是满足 is-a的关系 Student 是一个Person
        接口只需要满足like-a个关系 the Monkey like a Bird fly
    5.接口在一定程度上实现代码解耦。
三、多态：
    1.多态参数
        // usb接口变量，就体现多态-————多态参数
        pc     := &model.Computer{}
        phone  := &model.Phone{}
        camera := &model.Camera{}
        pc.Working(phone)  //多态参数
        pc.Working(camera) //多态参数
    2.多态数组
        // 多态数组：
        var usbArr [3]model.Usb //接口数组
        usbArr[0] = model.Phone{"Iphone x max"}
        usbArr[1] = model.Phone{"小米"}
        usbArr[2] = model.Camera{"Sony"}
        fmt.Println(usbArr)
`
type Interface interface {
    // Len方法返回集合中的元素个数
    Len() int
    // Less方法报告索引i的元素是否比索引j的元素小
    Less(i, j int) bool
    // Swap方法交换索引i和j的两个元素
    Swap(i, j int)
}


type Hero struct {
    Name string
    Age int
}

type HeroSlice []Hero

// 实现interface接口
func (hs HeroSlice) Len() int {
    return len(hs)
}

func (hs HeroSlice) Less(i,j int) bool {
    return hs[i].Age < hs[j].Age
}


func (hs HeroSlice) Swap(i,j int) {
    // 交换
    // temp := hs[i]
    // hs[i] = hs[j]
    // hs[j] = temp
    hs[i],hs[j] = hs[j],hs[i]
}


type Student struct {
    Name string
    Age int
    Score float64
}

type studentSlice []Student


func (ss studentSlice) Len() int {
    return len(ss)
}

func (ss studentSlice) Less(i,j int) bool {
    // return ss[i].Score < ss[j].Score
    // return ss[i].Age < ss[j].Age
    return ss[i].Name < ss[j].Name
}


func (ss studentSlice) Swap(i,j int) {
    ss[i],ss[j] = ss[j],ss[i]
}

func main() {
    // var intSlice = []int{0,-1,10,7,90}
    // 对切片排序
    // 1.冒泡排序
    // 2.系统提供的方法
    // sort.Ints(intSlice)
    // fmt.Println(intSlice)

    // var heros HeroSlice
    // for i := 0; i < 10; i++ {
    //  hero := Hero{
    //      Name:fmt.Sprintf("No.%.3d", rand.Intn(100)),
    //      Age :rand.Intn(100),
    //  }
    //  heros = append(heros,hero)
    // }

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

    // fmt.Println()
    // fmt.Println("排序后：")
    // // 调用sort.sort()
    // sort.Sort(heros)
    // for _,v :=range heros {
    //  fmt.Println(v)
    // }
    
    var students studentSlice
    for i := 0; i <10; i++ {
        student := Student{
            Name:fmt.Sprintf("No.%.3d", rand.Intn(100)),
            Age: rand.Intn(100),
            Score:float64(rand.Intn(100)),
        }
        students = append(students,student)
    }

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

    fmt.Println()
    fmt.Println("______________排序后：")
    // 调用sort.sort()
    sort.Sort(students)
    for _,v :=range students {
        fmt.Println(v)
    }
    
    fmt.Println()
    fmt.Println("———————————————————继承和接口—————————————")
    wukong := model.Wukong{
        model.Monkey{
            Name:"悟空[大师兄]",
        },
    }
    wukong.Climb()
    wukong.Flying()
    wukong.Swiming()

    fmt.Println()
    fmt.Println("———————————————————多态—————————————")
    pc     := &model.Computer{}
    phone  := &model.Phone{}
    camera := &model.Camera{}
    pc.Working(phone)
    pc.Working(camera)

    // 定义一个Usb接口数组，可以存放Phone和Camera结构体变量
    // 多态数组：
    var usbArr [3]model.Usb
    usbArr[0] = model.Phone{"Iphone x max"}
    usbArr[1] = model.Phone{"小米"}
    usbArr[2] = model.Camera{"Sony"}
    fmt.Println(usbArr)

}

monkey.go

package model

import (
    "fmt"
)

type Monkey struct {
    Name string
}

type Bird interface {
    Flying()
}

type Fish interface {
    Swiming()
}

func (this *Monkey) Climb() {
    fmt.Println(this.Name,"大闹天宫！！")
}


type Wukong struct {
    Monkey
}


func (this *Wukong) Flying() {
    fmt.Println(this.Name,"一个筋斗云~~~十万八千里(＾Ｕ＾)ノ~ＹＯ")
}

func (this *Wukong) Swiming() {
    fmt.Println(this.Name,"下海，找东海龙王玩~~获得如意棒，(*^__^*) 嘻嘻")
}

interface.go

package model

import (
    "fmt"
)
// 定义或声明一个接口
type Usb interface {
    // 声明两个没有实现的方法
    Start()
    Stop()
}

// 手机
type Phone struct {
    Name string
}
// 让phone实现Usb接口的方法
func (p Phone) Start() {
    fmt.Println("手机开始工作咯...")
}

func (p Phone) Stop() {
    fmt.Println("手机停止工作咯...")
}


// 相机
type Camera struct {
    Name string
}
// 让Camera实现Usb接口的方法
func (c Camera) Start() {
    fmt.Println("相机开始工作咯...")
}

func (c Camera) Stop() {
    fmt.Println("相机停止工作咯...")
}


// 计算机
type Computer struct {
    
}

// working方法，接收一个Usb接口类型变量
// 实现Usb接口---》实现Usb接口声明的所有方法。
// usb接口变量，就体现多态-————多态参数
func (c *Computer) Working(usb Usb) {
    // 通过usb接口变量来调用Start和Stop方法
    usb.Start()
    usb.Stop()
}

ます。https：//www.jianshu.com/p/1f8c01471345で再現