empty_interface

package main
import "fmt"
//type Empty interface {
//}
type Course struct {
    name  string
    price int
    url   string
}
type Printer interface {
    printInfo() string
}
func (c Course) printInfo() string {
    return "课程信息"
}
//func print(x interface{}) {
//    //此处的ok是bool类型
//    if v, ok := x.(int); ok { //判断是不是int类型
//        //x是int类型
//        fmt.Printf("%d, 整数\n", v)
//    }
//
//    if s, ok := x.(string); ok {
//        fmt.Printf("%s,字符串\n", s)
//
//    }
//    //牵扯到go的另一个默认的问题
//    //fmt.Printf("%v\n    ", i)
//}
type AliOss struct {
    //保存
    //下载
}
type LocalFile struct {
}
func store(x interface{}) {
    switch v := x.(type) {
    case AliOss:
        //此处要做一些特殊的处理,比如设置阿里云的权限问题
        fmt.Println(v)
    case LocalFile:
        //检查路径的权限
        fmt.Println(v)
    }
}
func print(x interface{}) {
    //类型断言
    switch x := x.(type) {
    case string:
        fmt.Printf("%s,字符串\n", x)
    case int:
        fmt.Printf("%d, 整数\n", x)
    case float64:
        fmt.Printf("%f, 浮点数\n", x)
    }
}
func main() {
    //空接口
    var i interface{} //有点像多态
    //空接口可以类似于我们java和python中的object
    //i = Course{}
    //fmt.Println(i)
    i = 10
    print(i)
    i = "hello"
    fmt.Println(i)
    //i = []string{"django", "scrapy"}
    //fmt.Println(i)
    //1.空接口的第一个用途,可以把任何类型都赋值给空接口变量
    //2.参数传递 什么类型都可以打印 什么类型都可以接收
    //3.空接口可以作为map的值
    //var teacherInfo = make(map[string]interface{})
    //teacherInfo["name"] = "wozen"
    //teacherInfo["age"] = 18
    //teacherInfo["weight"] = 72.5
    //teacherInfo["courses"] = []string{"hello", "world"}
    //fmt.Printf("%v\n", teacherInfo)
    //类型断言
    //接口的一个坑, 接口引入了
    //接口还有一个默认的规范 接口的名称以 er 结尾
    //c := &Course{}
    //var c Printer = Course{}
    //c.printInfo()
    //fmt.Println()
}

interface_test

package main
import (
    "fmt"
)
// Programmer 接口是一个协议 - 程序员 - 只要你能够1.写代码 2.解决bug 其实就是一组方法的集合
type Programmer interface {
    Coding() string //方法只是声明
    Debug() string
}
type Designer interface {
    Design() string
}
type Manager interface {
    Programmer
    Designer
    Manage() string
}
type G struct {
}
type Pythoner struct {
    UIDesigner
    lib   []string
    kj    []string
    years []int
}
//  Java的话 java里面一种类型只要继承一个接口才行 如果你继承了这个接口的话 那么这个接口里面的所有方法你必须要全部实现
type UIDesigner struct {
}
func (d UIDesigner) Design() string {
    fmt.Println("我会UI设计")
    return "我会UI设计"
}
func (p G) Coding() string {
    fmt.Println("go开发者")
    return "go开发者"
}
func (p G) Debug() string {
    fmt.Println("我会 go 的debug")
    return "我会go的debug"
}
func (p Pythoner) Coding() string {
    fmt.Println("python开发者")
    return "python开发者"
}
func (p Pythoner) Debug() string {
    fmt.Println("我会python的debug")
    return "我会python的debug"
}
func (p Pythoner) Manage() string {
    fmt.Println("不好意思,管理我也懂")
    return "不好意思,管理我也懂"
}
//func (p Pythoner) Design() string {
//    fmt.Println("我是一个python开发者,但是我会搞UI设计")
//    return "我是一个python开发者,但是我会搞UI设计"
//}
//对于 Pythoner 这个结构体来说 你实现任何方法都可以 但是你只要不全部实现这两个方法 那么你Pythoner结构体就不是一个Programmer类型
//1.Pythoner本身自己就是一个类型 那我何必在意我是不是Programmer
//2.封装 继承 多态 -多态的概念对于很多 Pythoner来说会有点陌生
//3.在讲解多态之前，我们来对interface做一个说明：在go语言中接口是一种类型 是一种抽象类型
func HandlePy(pythoner Pythoner) {
}
func HandleGo(g G) {
}
//func HandleJava(pythoner Pythoner) {
//
//}
type myError struct {
}
func (m myError) Error() string {
    return "错误"
}
func main() {
    //新的语言出来了 接口帮我们完成了go语言的多态
    //var pro Programmer = Pythoner{}
    //var g G = G{}
    //pro.Coding()
    var pros []Programmer
    pros = append(pros, Pythoner{})
    pros = append(pros, G{})
    //接口虽然是一种类型 但是和其他类型不太一样 接口是一种抽象类型 struct 是具象
    p := Pythoner{}
    fmt.Printf("%T\n", p)
    var pro Programmer = Pythoner{}
    var pro2 Programmer = G{}
    fmt.Printf("%T\n", pro)
    fmt.Printf("%T\n", pro2)
    //如果大家对于面向对象理解的话 java 里面的抽象类型有点像
    //1. go struct 组合 组合一起实现了所有的接的方法也是可以的
    //2.接口本身也支持组合
    var m Manager = Pythoner{}
    //struct 组合完成了接口 1.接口支持组合 - 继承2.结构体组合实现了所有的接口方法也没有问题
    m.Design()
    //python语言本身设计上是采用了完全的基于鸭子类型 - 协议 影响了python语法的for len()
    //go语言也推荐鸭子类型 error
    //var err error = error() //并不能实例化 抽象类型
    //var err error = myError{}
    //var err error = errors.New("错误")
    s := "文件不存在"
    var err error = fmt.Errorf("错误：%s", s)
    fmt.Println(err)
}
//开发中经常会遇到的问题
//开发一个电商网站 支付环境 wx zfb yhk 你的系统支持各种类型的支付 每一种支付类型都有统一的接口
//定一个协议 1. 支付 2.创建订单 3.查询支付状态 4.退款
//支付发起了
//type AliPay struct {
//}
//
//type WeChat struct {
//}
//type Bank struct {
//}
//
//var b Bank
//var a AliPay
//var w WeChat
type Tongyong struct {
}
//多态 声明类型的时候你声明的类型是一种兼容类型,但是实际赋值的时候是另一种类型
//接口是强制性
//你现在有一个缓存系统 - 这个地方你一开始使用的缓存是redis 但是后期你考虑到可能使用其他的缓存技术 - 本地 memcache
/*
    var x Tongyong
    x = Bank{}
    x = AliPay{}
    x = WeChat{}
    x.pay
    x.create
    x.query
*/
//这种多态特性 其实在python中不需要多态 python是动态语言
//go语言中并不支持继承
//如果后期接入一种新的支付 或者取消已有的支付

sort_test

package main
import (
    "fmt"
    "sort"
)
type Course struct {
    Name  string
    Price int
    Url   string
}
type Courses []Course
func (c Courses) Len() int {
    return len(c)
}
func (c Courses) Less(i, j int) bool {
    return c[i].Price < c[j].Price
}
func (c Courses) Swap(i, j int) {
    c[i], c[j] = c[j], c[i]
}
func main() {
    //通过sort来排序
    //让你写一个排序算法 冒泡 快速 桶 归并 桶排序 算法本质是一样的 比较 计数排序
    //你的排序算法是否能应付各种类型的排序
    courses := Courses{
        Course{"django",300,""},
        Course{"scrapy",100,""},
        Course{"go",150,""},
        Course{"tornado",200,""},
    }
    sort.Sort(courses) //协议 你的目的不是要告诉别人具体的类型,重要的是你的类型必须提供具体的方法
    for _ , v := range courses {
        fmt.Println( v)
    }
    //data := []int{1, 3, 6, 7, 2}
    //sort.Sort(data) //协议
    /*
        无法将 'data' (类型 []int) 用作类型 Interface 类型未实现 'Interface'，
        因为缺少某些方法: Len() int Less(i int, j int) bool Swap(i int, j int)
    */
    //grpc
    //go语言的包以及编码规范 包管理 1.12之前 python java maven go-modules
}