Go04基础

1 结构体

1 结构体的使用  值类型
	定义:
        type Person struct {
        	Name string
        	Age int
        	sex string       	
        }
    使用:   
	var per Person
	fmt.Println(per)
	per.Name="lqz"
	per.Age=19
	fmt.Println(per)
2 定义并赋初值
	var per =Person{Name:"lqz"}   //不按位置，少传
	var per2 n=entity.Person{"lqz",19,"男"}   //按位置，全穿
	fmt.Println(per2)
	per2.Age=20
	fmt.Println(per2)
3 匿名结构体（定义在内部（函数，结构体），只使用一次，没有名字）
	 有什么用？当定义多个变量（想一次使用），就可以把这多个变量放到匿名结构体中
	a := struct {
		HobbyId   int64
		HobbyName string
	}{HobbyId: 1, 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 *Person
	fmt.Println(per)
	定义并初始化
	var per *Person=&Person{}
	fmt.Println(per)
	//把per的名字改成lqz
	(*per).Name="lqz"
	//支持直接使用(数组也是这样，自动帮你处理了)
	per.Name="egon"
	fmt.Println(per)
7 匿名字段（字段没有名字，只有类型）
	【变量提升/提升字段】面向对象的继承
    type Person struct {	
        string
        int
        sex string
        Hobby
    }
	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 字段提升
    type Person struct {	
        Name string
        Age int
        sex string
        Hobby
    }
    type Hobby struct {
        Id int
        Name string
    }
	var per Person =Person{"lqz",19,"男",Hobby{1,"篮球"}}
	//打印爱好的名字(Hobby是一个匿名字段,会字段提升)
	fmt.Println(per.HobbyName)
	fmt.Println(per.Hobby.HobbyName)  //per.Hobby 类似于面向对象中的super()
	//像什么?像面向对象的继承  子类继承父类(结构体嵌套,匿名字段),子类可以直接调用父类中的属性或方法
10 导出结构体和字段 大写字母开头,在外部包可以使用
11 结构体相等性
	结构体是值类型。
	如果它的每一个字段都是可比较的，则该结构体也是可比较的。 如果两个结构体变量的对应字段相等，则这两个变量也是相等的
如果结构体包含不可比较的字段，则结构体变量也不可比较。

2 方法

package main

//方法:特殊函数,在函数的基础上加了一些东西
//在 func 这个关键字和方法名中间加入了一个特殊的接收器类型,接收器可以是结构体类型，也可以是非结构体类型
type Person2 struct {
	Name string
	Age int
	Sex string
}

func (p Person2) printName()  {
在方法内可以使用p
	fmt.Println(p.Name)
}
修改名字、
1.值传递
func (p Person2) changeName(name string)  {
	p.Name=name
	fmt.Println(p)  //值传递  无法修改原来的
}
修改年龄方法
2.引用传递
func (p *Person2) changeAge(age int)  {
	fmt.Println(p.Age)  //推荐用这个
	p.Age=age
}    //引用   可以修改原来的



3.匿名字段的方法
	方法提升

4.在方法中使用值接收器 与 在函数中使用值参数
type Person2 struct {
	Name string
	Age int
	Sex string
}
5.在方法中使用值接收器
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)
}
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)
	fmt.Println(p.Name)
}
//值收器:可以用值来调，也可以用指针来调
//函数的值参数，只能传值
//总结：不管是值类型接收器还是指针类型接收器，都可以用值来调用，或者指针来调用
//总结：不管是值还是指针来调用，只要是值类型接收器，改的就是新的，只要是指针类型接收器，改的是原来的
7.非结构体上的方法（不允许）自己定义的类型可以绑定方法
	可以在自定义的类型上绑定方法
type Myint  int
func (i *Myint)add(){
	(*i)=(*i)+1
	i++
	i+=1
}

3 接口

//go也是鸭子类型：我现在有个鸭子类，内有speak方法   有run方法，  子类只要实现了speak和run，我就认为子类是鸭子
//在java中，子类必须实现鸭子类的所有方法，子类才叫鸭子
//接口：面向对象的领域里，接口一般这样定义：接口定义一个对象的行为，规范子类对象的行为
//接口：是一系列方法的集合（规范行为）
1 定义接口（定义一个鸭子接口，speak方法，run方法）
type Duck interface {
	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)
}
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结构体对象
	v, ok = duck.(PDuck)    //断言失败,ok是false，v是PDuck类型的空置，因为没有复制
5 类型选择(通过switch)
func test(a 接口名字){
    switch v:=a.(type){
        case type1:
            此时v就是type1的结构体
        case type2:
            此时v就是type2的结构体
        ...      
    }
}
6 空接口（没有任何方法，所有数据类型都实现了空接口）
7 匿名空接口 没有名字的空接口  一般用在形参上
8 之前学过的集合类型，都可以放接口类型
	var a map[string]interface{}= make(map[string]interface{})
    a["name"]="lqz"
	a["age"]=19
	a["duck"]=PDuck{}
9 接口的零值
	nil 
10  接口的嵌套
type Animal interface {
	eat()
	sleep()
}
type Duck interface {
	Animal    //套用之前的
	speak()
	run()
}
11.重要概念*****
	*****接口是一种类型，一个结构体可以实现多种接口，当该结构体可以被转成某种接口，只能使用该接口的方法，当然，该接口也可以转成另一种接口，也可以转成结构体

4 make和new的区别

make是引用类型初始化的时候用的	
new 是返回指向这个类型的指针
//var per *PDuck1 =new(PDuck1)    //new 是返回指向这个类型的指针
//var per2 = make([]int,3,4)  //make是具体的造引用类型  

5 结构体取代类(给结构体设置默认值)

1.test包下下
	package test
	定义一个结构体
    type Cat struct {
        Name string
        Age  int
    }
	func new()  Cat {
        return Cat{Name:"默认值"...}    
}
2.在其他包调用
	cat:=test.new()  //也可以设置成传参数