Go 结构体 方法 接口

结构体

package main

import "fmt"

//结构体：一系列属性的集合
//定义结构体(在包中定义了)


//7 定义一个结构体，内涵匿名字段（字段没有名字）  匿名字段类型就是字段名，所有类型不能重复
//type Person struct {
//    string
//    int
//    sex string
//}


//8 嵌套结构体(结构体中套结构体)

//type Person struct {
//    Name string
//    Age int
//    sex string
//    Hobby Hobby
//}
//type Hobby struct {
//    HobbyId int
//    HobbyName string
//}

//9 字段提升
//type Person struct {
//    Name string
//    Age int
//    sex string
//    Hobby
//}
//type Hobby struct {
//    HobbyId int
//    HobbyName string
//}

//type Person struct {
//    Name string
//    Age int
//    sex string
//    Hobby
//}
//type Hobby struct {
//    Id int
//    Name string
//}


//11 结构体相等性

type Person struct {
    Name string
    Age int
    sex string
    //包含不可比较的字段
    AAA []int
}

func main() {
    //1 结构体的使用  值类型
    //var per entity.Person
    //fmt.Println(per)
    //per.Name="lqz"
    //per.Age=19
    //fmt.Println(per)

    //2 定义并赋初值
    //var per entity.Person=entity.Person{Name:"lqz"}   //不按位置，少传
    //var per2 entity.Person=entity.Person{"lqz",19,"男"}   //按位置，全穿
    //fmt.Println(per2)
    //per2.Age=20
    //fmt.Println(per2)

    //3 匿名结构体（定义在内部（函数，结构体），只使用一次，没有名字）
    // 有什么用？当定义多个变量（想一次使用），就可以把这多个变量放到匿名结构体中
    //a := struct {
    //    HobbyId   int64
    //    HobbyName string
    //}{HobbyId: 1, HobbyName: "篮球"}
    //
    //fmt.Println(a.HobbyName)
    //a.HobbyName="足球"
    //fmt.Println(a.HobbyName)

    //4 结构体的零值,值类型
    //var per entity.Person
    //fmt.Println(per)  //属性的零值，值类型，参数传递，copy传递，在函数中修改，不会影响原来的
    //test2(per)
    //fmt.Println(per)

    //5 访问结构体字段 ，通过 . 来访问  注意大小写

    //6 结构体的指针
    //var per *entity.Person
    //fmt.Println(per)

    //定义并初始化
    //var per *entity.Person=&entity.Person{}
    //fmt.Println(per)
    ////把per的名字改成lqz
    //(*per).Name="lqz"
    ////支持直接使用(数组也是这样，自动帮你处理了)
    //per.Name="egon"
    //fmt.Println(per)


    //7 匿名字段（字段没有名字，只有类型）
    //【变量提升/提升字段】面向对象的继承
    //per:=Person{"lqz",19,"男"}
    //per:=Person{string:"lqz",int:19,sex:"男"}  //字段匿名，类型就是字段名
    //fmt.Println(per)
    //fmt.Println(per.string)
    //fmt.Println(per.int)

    //8 嵌套结构体(结构体中套结构体)
    //var per Person =Person{"lqz",19,"男",Hobby{1,"篮球"}}
    //var per Person =Person{Name: "lqz",Age: 19,sex: "男"}
    //var per Person =Person{Name: "lqz",Age: 19,sex: "男",Hobby:Hobby{1,"足球"} }
    //var per Person =Person{Name: "lqz",Age: 19,sex: "男",Hobby:Hobby{HobbyId: 1,HobbyName: "足球"}}
    //fmt.Println(per.Name)
    //fmt.Println(per.Hobby.HobbyName)

    //9 字段提升
    //var per Person =Person{"lqz",19,"男",Hobby{1,"篮球"}}
    //var per Person =Person{Name: "lqz",Age: 19,sex: "男",Hobby:Hobby{HobbyId: 1,HobbyName: "足球"}}
    ////打印爱好的名字(Hobby是一个匿名字段,会字段提升)
    //fmt.Println(per.HobbyName)
    //fmt.Println(per.Hobby.HobbyName)  //per.Hobby 类似于面向对象中的super()
    ////像什么?像面向对象的继承  子类继承父类(结构体嵌套,匿名字段),子类可以直接调用父类中的属性或方法

    //var per Person =Person{Name: "lqz",Age: 19,sex: "男",Hobby:Hobby{ 1, "足球"}}
    //fmt.Println(per.Name)  //优先使用自己的
    ////打印出hobby的名字
    //fmt.Println(per.Hobby.Name)

    //10 导出结构体和字段 大写字母开头,在外部包可以使用

    //11 结构体相等性
    //结构体是值类型。
    //如果它的每一个字段都是可比较的，则该结构体也是可比较的。 如果两个结构体变量的对应字段相等，则这两个变量也是相等的
    //如果结构体包含不可比较的字段，则结构体变量也不可比较。

    //值类型,可以直接==比较,引用类型只能跟nil用==比较
    //per1:=Person{Name: "lqz"}
    //per2:=Person{Name: "lqz",Age:19}
    //fmt.Println(per1==per2)

    //per1:=Person{Name: "lqz"}
    //per2:=Person{Name: "lqz",Age:19}
    //fmt.Println(per1==per2) //包含不可比较的属性
    fmt.Println("lqz nb")

}
//func test2(per entity.Person)  {
//    per.Age=99
//    fmt.Println(per)
//}

方法

package main

//方法:特殊函数,在函数的基础上加了一些东西
//在 func 这个关键字和方法名中间加入了一个特殊的接收器类型,接收器可以是结构体类型，也可以是非结构体类型
//type Person2 struct {
//    Name string
//    Age int
//    Sex string
//}
//
////def add(self):
////    self.name
////    pass
////定义一个方法  : (p Person2) 绑定给了Person2结构体的对象
//func (p Person2) printName()  {
//    //在方法内可以使用p
//    fmt.Println(p.Name)
//}
////修改名字
//func (p Person2) changeName(name string)  {
//    p.Name=name
//    fmt.Println(p)
//}
////修改年龄方法
//func (p *Person2) changeAge(age int)  {
//    //fmt.Println(p.Age)  //推荐用这个
//    p.Age=age
//}
//
//func printName(p Person2)  {
//    fmt.Println(p.Name)
//}


// 匿名字段的方法
//type Person2 struct {
//    Name string
//    Age int
//    Sex string
//    Hobby  //匿名字段
//}
//type Hobby struct {
//    Id int
//    Name string
//}
//
////给结构体绑定方法
//func (p Person2)printName()  {
//    fmt.Println(p.Name)
//}
////func (h Hobby)printHobbyName()  {
//func (h Hobby)printName()  {
//    fmt.Println(h.Name)
//}



/// //6 在方法中使用值接收器 与 在函数中使用值参数
//type Person2 struct {
//    Name string
//    Age int
//    Sex string
//}
////在方法中使用值接收器
//func (p Person2)printName()  {
//    fmt.Println(p.Name)
//}
//func (p Person2)changeName(name string)  {
//    p.Name=name
//    fmt.Println(p)
//}
////在函数中使用值参数
//func printName(p Person2)  {
//    fmt.Println(p.Name)
//}


//7 在方法中使用指针接收器 与 在函数中使用指针参数
//type Person2 struct {
//    Name string
//    Age int
//    Sex string
//}
////在方法中使用值接收器
//func (p *Person2)printName()  {
//    fmt.Println(p.Name)
//}
//func (p *Person2)changeName(name string)  {
//    p.Name=name
//    fmt.Println(p)
//}
////在函数中使用指针参数
//func printName(p *Person2)  {
//    //fmt.Println((*p).Name)
//    fmt.Println(p.Name)
//}



//8 非结构体上的方法（不允许）自己定义的类型可以绑定方法
//在int类型上绑定一个add方法
//不允许
//func (i int)add(){
//    i=i+1
//    i++
//    //i+=1
//}

// 可以在自定义的类型上绑定方法
type Myint  int
func (i *Myint)add(){
    (*i)=(*i)+1
    //i++
    //i+=1
}
func main() {

    //1 方法的定义和使用
    //per:=Person2{}
    //per.Name="lqz"
    //per.printName()  //绑定给对象的方法
    //
    //per1:=Person2{Name: "egon"}
    //per1.printName()

    //2 为什么我们已经有函数了还需要方法呢？
    //per1:=Person2{Name: "egon"}
    ////per1.printName()  //方法的特殊之处，可以自动传值
    ////
    ////printName(per1)
    //per1.changeName("lqz")
    //
    ////并没有改
    //fmt.Println(per1)

    //3 指针接收器与值接收器
    //per1:=Person2{Name: "egon",Age: 18}
    //fmt.Println(per1)
    //per1.changeAge(99)
    //fmt.Println(per1)

    //4 时候使用指针接收器，什么时候使用值接收器：想改原来的，就用指针，不想改原来的就用值（指针用的多）

    //5 匿名字段的方法(方法提升)

    //per1:=Person2{Name: "lqz",Hobby:Hobby{1,"足球"}}
    ////per1.printHobbyName()  //Hobby是个匿名字段，方法也提升了
    ////如果方法名冲了，优先用该结构体自己的
    //per1.printName()
    //per1.Hobby.printName()

    //6 在方法中使用值接收器 与 在函数中使用值参数
    //per1:=Person2{Name: "lqz"}
    //per1.printName()
    //printName(per1)

    //per1:=&Person2{Name: "lqz"}  //per1是个指针
    //per1.printName()
    //printName(*per1)

    //小研究
    //per1:=&Person2{Name: "lqz"}  //per1是个指针
    //per1.changeName("egon")
    //fmt.Println(per1)

    //值收器:可以用值来调，也可以用指针来调
    //函数的值参数，只能传值

    //7 在方法中使用指针收器 与 在函数中使用指针参数

    //per1:=Person2{Name: "lqz"}
    //per1.printName()  //值可以来调用
    //printName(&per1)

    //per1:=&Person2{Name: "lqz"}
    //per1.printName()  //指针可以来调用
    //printName(per1)

    //小研究
    //per1:=Person2{Name: "lqz"}
    //per1.changeName("egon")
    //fmt.Println(per1)

    //per1:=&Person2{Name: "lqz"}
    //per1.changeName("egon")
    //fmt.Println(per1)

    //总结：不管是值类型接收器还是指针类型接收器，都可以用值来调用，或者指针来调用
    //总结：不管是值还是指针来调用，只要是值类型接收器，改的就是新的，只要是指针类型接收器，改的是原来的
    //a:=1
    //a+=1
    //a++
    //a=a+1
    //++a  //java中有++a
    //fmt.Println(a)

    //8 非结构体上绑定方法
    //var a Myint =10
    //fmt.Println(a)
    //a.add()
    //a.add()
    //a.add()
    //a.add()
    //fmt.Println(a)
    //



    //var b =11
    ////fmt.Println(a+b)  //类型不匹配
    //
    //c:=a+Myint(b)
    //fmt.Println(a+Myint(b))  //类型匹配
    //d:=int(a)+b
    //fmt.Println(int(a)+b)  //类型匹配


}

接口

package main

//go也是鸭子类型：我现在有个鸭子类，内有speak方法   有run方法，  子类只要实现了speak和run，我就认为子类是鸭子
//在java中，子类必须实现鸭子类的所有方法，子类才叫鸭子
//接口：面向对象的领域里，接口一般这样定义：接口定义一个对象的行为，规范子类对象的行为
//接口：是一系列方法的集合（规范行为）

//1 定义接口（定义一个鸭子接口，speak方法，run方法）
//type Duck interface {
//    speak()  //speak()方法
//    run()
//}
//
////定义一个普通鸭子结构体
//type PDuck struct {
//    name string
//    sex string
//    age int
//}
//
////定义一个唐老鸭结构体
//type TDuck struct {
//    name string
//    sex string
//    age int
//    wife string
//}
////让唐老鸭和普通鸭子都实现Duck接口
////结构体实现一个接口：只要绑定接口中的所有方法，就叫实现该接口
//func (p PDuck)speak()  {
//    fmt.Println("普通鸭子嘎嘎叫,普通鸭子名字叫",p.name)
//}
//func (p PDuck)run()  {
//    fmt.Println("普通鸭子歪歪扭扭走了,普通鸭子名字叫",p.name)
//}
//
////唐老鸭也实现Duck接口
//func (p TDuck)speak()  {
//    fmt.Println("唐老鸭说人话,唐老鸭子名字叫",p.name)
//}
//func (p TDuck)run()  {
//    fmt.Println("唐老鸭人走路,唐老鸭子名字叫",p.name)
//}
//
//
////6 空接口定义
//type Empty interface {
//}

func main() {
    //1 得到一个普通鸭子对象
    //pduck:=PDuck{"黑子","男",1}
    //pduck.run()
    //pduck.speak()
    ////2 得到一个堂老鸭子对象
    //tduck:=TDuck{"egon","男",1,"刘亦菲"}
    //tduck.run()
    //tduck.speak()

    //侵入式接口（接口没了，子类报错）和非侵入是接口（接口没了，不影响代码，go语言中的接口是非侵入式的）

    //2 接口的实际用途（接口也是一个类型）
    //var duck Duck
    ////pduck:=PDuck{"黑子","男",1}
    //tduck:=TDuck{"egon","男",1,"刘亦菲"}
    ////duck=pduck
    //duck=tduck  //多态，同一类事务多种形态
    //duck.run()

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

    //4 把接口类型转成struct，属性，自有方法也有了，类型断言
    //类型断言
    //var duck Duck =TDuck{"egon","男",1,"刘亦菲"}
    ////断言是TDuck类型
    ////v, ok := duck.(TDuck)
    //////断言成功，ok是true，v就是TDuck结构体对象
    ////fmt.Println(v)
    ////fmt.Println(v.name)
    ////fmt.Println(ok)
    //
    ////断言失败
    //var v PDuck
    //var ok bool
    //v, ok = duck.(PDuck)
    ////断言失败,ok是false，v是PDuck类型的空置，因为没有复制
    //fmt.Println(ok)
    //fmt.Println(v)

    //5 类型选择(通过switch)
    //var duck Duck =TDuck{"egon","男",1,"刘亦菲"}
    ////var duck Duck =PDuck{"egon","男",1}
    //test4(duck)

    //6 空接口（没有任何方法，所有数据类型都实现了空接口）
    //var a int=10
    //var b string="lqz"
    //var c [3]int
    //var e Empty  //空接口类型
    //e=a
    //e=b
    //e=c
    //fmt.Println(e)
    //fmt.Println(1,"xxx")
    //test5(a)
    //test5(b)
    //test5(c)

    //7 匿名空接口 没有名字的空接口  一般用在形参上
    //test6(10)
    //test6("lll")
    //var duck TDuck =TDuck{"egon","男",1,"刘亦菲"}
    //test6(duck)

    //8 之前学过的集合类型，都可以放接口类型
    //var a[3]Duck
    //a[1]=PDuck{}
    //a[2]=TDuck{}
    //var a map[string]interface{}= make(map[string]interface{})
    //a["name"]="lqz"
    //a["age"]=19
    //a["duck"]=PDuck{}


}
//func test6(b interface{})  {
//    fmt.Println(b)
//}



//func test5(b Empty)  {
//    switch v:=b.(type) {
//    case string:
//        fmt.Println("我是字符串")
//        fmt.Println(v)
//    case int:
//        fmt.Println("我是int")
//        fmt.Println(v)
//    case [3]int:
//        fmt.Println("我是数组")
//        fmt.Println(v)
//    }
//}



//func test4(duck Duck)  {
//    if v,ok:=duck.(TDuck);ok{
//        fmt.Println("我是普通鸭子")
//        fmt.Println(v)
//    }else if v,ok:=duck.(PDuck);ok {
//        fmt.Println("我是普通鸭子")
//        fmt.Println(v)
//    }
//}

//使用switch，选择成功，拿到结构体对象
//func test4(duck Duck)  {
//    switch v:=duck.(type) {
//    case PDuck:
//        fmt.Println(v.name)
//        fmt.Println("我是普通鸭子")
//    case TDuck:
//        fmt.Println(v.wife)
//        fmt.Println("我是唐老鸭")
//    default:
//        fmt.Println(v)
//        fmt.Println("我是鸭子这个类")
//
//    }
//}

 make和new的区别

package main

//make和new的区别
type PDuck1 struct {
    name string
    sex string
    age int
}
func main() {
    //make是引用类型初始化的时候用的
    //var per *PDuck1 =new(PDuck1)    //new 是返回指向这个类型的指针
    //fmt.Println(per)
    //
    //
    //var per1 =&PDuck1{}
    //fmt.Println(per1)

    //var per2 = make([]int,3,4)  //make是具体的造引用类型  //new是造指向这个类型的指针
    //var per2 *[]int= new([]int)
    //fmt.Println(per2)
    //(*per2)=append((*per2),99)
    //fmt.Println(per2)


}

结构体取代类

package main

import (
    person "day04/Person"
    "fmt"
)

func main() {
    per :=person.New("lqz",19,"男")

    //var per Person = new Person("lqz",19,"男")
    fmt.Println(per)
    per.PrintName()
}