1 方法

//方法 
  1.是特殊的函数，可以自动传值 ---> 对象(go中就是结构体)来调用，自动把对象(当前结构体的实例)传过来

  2.在func关键字 和 方法名 中间加入了一个特殊的接收器类型
    接收器可以是结构体类型或者是非结构体类型
    接收器是可以在方法的内部访问的
  
  3.方法是绑定给结构体的 ---> 如何绑定


  4.方法如何给非结构体类型绑定  ---> 将 非结构体类型 重命名，再绑定
    
  eg:
    type Myint int8

    func (p *Myint) add(){
        (*p) +=1
    }


//总结：go中没有面向对象的概念，但是能够实现面向对象
  1.结构体            --->  类的一半，只有属性
  2.结构体 + 匿名字段  --->  类的继承
  3.结构体 + 方法      --->  类的另一半，类中的方法   实例化结构体后，可以自动传值(当前对象)



package main

import "fmt"


//定义了一个结构体
type Person1 struct {
    name string
    age  int
}


//给结构体绑定方法   
func (p Person1) PrintName() { 
    fmt.Println(p.name)
}


// (p Person1)   值类型接收器，接受的是当前结构体的实例(当前对象) 的copy一份
func (p Person1) ChangeName(name string) {
    p.name = name   //修改该结构体的实例 属性，不会影响原来结构体实例
    fmt.Println(p)
}

// (p *Person1)  指针类型接收器，接受的是当前结构体的实例(当前对象) 的指针 
                               就是python中的self，是原值的引用
func (p *Person1) ChangeAge(age int) {
    p.age = age    //修改该结构体的实例 属性，会影响原来结构体实例
    fmt.Println(p)
}


//定义的是打印name的函数
func PrintName(p Person1) {

}



func main() {
    //1 使用方法
    var p Person1=Person1{"lqz",19}
    p.PrintName()

    
    //2 为什么我们已经有函数了还需要方法呢
        区别在于：使用方式 和 自动传值
    
    PrintName(p)  //函数调用，需要手动传参
      

    //3 指针接收器与值接收器 ---> 取别在于修改会不会影响原来的对象
    var p Person1 = Person1{"lqz", 19}
    
    p.ChangeName("彭于晏")
    fmt.Println("修改后的：",p)  //{"lqz", 19}  没有改

    
    //5 接收器使用场景 ---> 如果想改原来的值，用指针类型接收器
    var p Person1 = Person1{"lqz", 19}
    
    p.ChangeAge(99)
    fmt.Println("修改后的：",p) //{"lqz", 99}  修改


    //5 匿名字段的方法 ---> 方法提升
    p:=Person2{"lqz",18,Hobby2{"篮球",1}}
    fmt.Println(p)
    
    //p.hobby.printName()
    p.printName()  //方法提升了

}


//5 匿名字段的方法 ---> 方法提升
type Hobby2 struct {
    hobbyName string
    hobbyId int
}

type Person2 struct {
    name string
    age int
    //hobby Hobby2
    Hobby2  //匿名字段
}

func (h Hobby2) printName()  {
    fmt.Println(h.hobbyName)
}

2 接口

//接口:   就是python中的多态
  1.一系列方法的集合，约束子类的行为

  2.go也是鸭子类型，是非侵入式接口


//侵入式接口和非侵入式接口
  非侵入式接口：删除接口后，基于该接口的结构体不会报错   eg: go

  侵入式接口：删除接口后，基于该接口的类会报错   eg:java



package main

import (
    "fmt"
)

//定义一个鸭子接口
type Duck interface {
    run()
    speak()
}

//定义一个空接口 ---> 所有类型都实现了空接口
type Empty interface {
}


//定义普通鸭结构体
type PDuck struct {
    age  int
    name string
}

//定义唐老鸭结构体
type TDuck struct {
    age  int
    name string
    wife string
}


//让普通鸭实现Duck接口 ---> 只要实现了接口中所有方法，就叫实现该接口
func (p PDuck) run() {
    fmt.Println("普通鸭子，走路歪歪扭扭")
}
func (p PDuck) speak() {
    fmt.Println("普通鸭子，嘎嘎叫")
}


//让唐老鸭实现Duck接口 ---> 只要实现了接口中所有方法，就叫实现该接口
func (p TDuck) run() {
    fmt.Println("人走路")
}
func (p TDuck) speak() {
    fmt.Println("人叫")
}




func main() {
    var p PDuck = PDuck{1, "肉鸭一号"}
    var t TDuck = TDuck{5, "唐老鸭", "母唐老鸭"}
    
    //唐老鸭和普通鸭，都可以赋值给鸭子接口类型，就可以都当做 鸭子接口 去操作
    var d Duck
    d = p
    d = t
    
    d.run()
    d.speak()

    
    //1 类型断言  d.(类型): 判断该接口是否 是这个类型，并返回该类型对应的值
                     作用：可以通过 接口类型，获取到原本类型的实例
                     返回值: 获取该对象、布尔值
    
    if v,ok := d.(TDuck); ok{
        fmt.Println(v.name)
    }else {
        fmt.Println("断言失败，不是唐老鸭类型")
    }

        
    //2 空接口类型  所有类型都可以赋值给空接口
    var a Empty=1
    
    a="lqz"
    a=[]int{1,2,3}
   
    //3 匿名空接口  
    interface{}
    
    
    //5 类型选择  就是 类型断言 + Switch + 空接口 的结合
    a := "lqz"
    a := []int{1, 2, 3}
    test(a)
    
    t := TDuck{wife: "李易峰"}
    test(t)
}

    
//5 类型选择  作用：可以通过 接口类型，获取到原本类型的实例

//func test(i interface{}){    //函数参数 是 匿名空接口
func test(i Empty) {
    switch v:=i.(type) {   // i.(type)可以返回i对应类型的值，但.(type)只能在switch内使用
    case int:
        fmt.Println("是int")
    case string:
        fmt.Println("是字符串")
    case TDuck:
        fmt.Println(v.wife)
        fmt.Println("是唐老鸭类型")
    default:
        fmt.Println("不知道什么类型")
    }
}

3 泛型

//泛型编程
  通过引入 类型形参 和 类型实参 这两个概念
  让一个函数获得了处理多种不同类型数据的能力


//理解案例：
  定义一个int类型的add函数，但是不能处理int以外的类型
  
  泛型就是将add函数的 参数类型不固定，等到实际传入参数时，再给定具体类型
  从而实现同一个函数，处理 除类型以外的 相同逻辑的功能 

  python 没有泛型一说，但是可以通过 注释等提示，实现人为约束的 泛型
  因为python本身就是动态类型，变量没有固定类型，可以指向所有类型
  是一切皆对象，都是对象的引用
  传入什么对象，就是什么对象的类型使用


//使用场景
  如果你经常要分别为不同的类型写完全相同逻辑的代码，那么使用泛型将是最合适的选择


//具体实现   参考 https://segmentfault.com/a/1190000041634906