Go语言学习之旅十九--复习指针，结构体

一、指针知识点大概：
指针：
存储量另一个变量的内存地址的变量
函数指针：一个指针，指向了一个函数的指针。
因为go语言中，function，默认看作一个指针，没有*
指针函数：一个函数，该函数的返回值是一个指针。
指针作为参数：
参数的传递：值传递，引用传递

部分代码示例：

a:=10
	fmt.Println("a的数值：",a)
	fmt.Printf("%T\n",a)
	fmt.Printf("a的地址是：",&a)

	//2.创建一个指针变量，用于存储变量a的地址
	var p1 *int
	fmt.Println(p1)//空指针
	p1=&a//p1指向了a的内存地址
	fmt.Println("p1的数量：",p1)//p1中存储的是a的地址
	fmt.Printf("p1自己的地址：%T\n",&p1)
	fmt.Println("p1的数值，是a的地址，该地址存储的数据：",*p1)


	//3.操作变量，更改数值
	a=100
	fmt.Println(a)
	fmt.Printf("%p\n",&a)

	//4.通过指针，改变变量的数值
	*p1=200
	fmt.Println(a)
	//5.指针的指针
	var p2 **int
	fmt.Println(p2)
	p2=&p1
	fmt.Printf("%T,%T,%T\n",a,p1,p2)//int,*int,**int
	fmt.Println("p2的数值",p2)
	fmt.Printf("p2自己的地址:%p\n",&p2)
	fmt.Println("p2中储存的地址,对应的数值，就是p1的地址，对应的数值",*p2)

var a func()
	a=fun1
	a()

	arr1:=fun2()
	fmt.Printf("arr1的类型：%T,,地址：%p,数值：%v\n",arr1,&arr1,arr1)

	 arr2:=fun3()
	 fmt.Printf("arr2的类型：%T,地址：%p,数值：%v\n",arr2,&arr2,arr2)
}
func fun1()  {
	fmt.Println("fun1().....")
}
func fun2()[4]int{
    arr:=[4]int{1,2,3,4}
	return arr
}
func fun3()*[4]int  {

	arr:=[4]int{5,6,7,8}
	return &arr
}

函数是一个指针。
参数传递如果是值传递，那么不会传递地址，值传递完之后，系统会将其地址删除
引用传递是传递地址。如下图代码所示：

var a func()
	a=fun6
	a()

	arr1:=fun7()
	fmt.Printf("aarr1的类型：%T,地址：%p,数值：%v\n",arr1,&arr1,arr1)


	arr2:=fun8()
	fmt.Printf("arr2的类型：%T,地址：%p,数值：%v\n",arr2,&arr2,arr2)

}
func fun8()*[4]int  {
     arr:=[4]int{5,6,7,8}
	 return &arr
}
func fun6()  {
	fmt.Println("fun1()//")
}
func fun7()[4]  int{
	arr:=[4]int{1,2,3,4}
	return arr
}

二、结构体内容概括
结构体：是由一系列具有相同类型或不同类型或不同类型的数据构成的数据集合
结构体成员是由一系列的成员变量构成，这些成员变量也被称为"字段"
数据类型：
值类型：int,float,bool,string,array,struct
引用类型：slice,map,function,poiter
匿名函数和匿名字段：

匿名结构体：没有名字的结构体
   在创建匿名结构体时，同时创建对象
   变量名：=struct{
定义字段Field
    }{
对字段进行赋值
}
匿名字段：一个结构体的字段没有字段名
	面向对象：oop
Go语言中结构体嵌套：
     1.模拟继承性：is-a
      type A struct{
             field
}
type B struct{
A //匿名字段
}
2.模拟聚合关系
     has-a
type C struct{
field
}
type D Struct{
c C

部分代码示例：

引用一个结构体的四种方法（大同小异）：

var p1 Person
	fmt.Println(p1)
	p1.name="王二狗"
	p1.age=30
	p1.sex="男"
	p1.address="北京"
	fmt.Printf("姓名·：%s,年龄：%d,性别：%s,地址：%s\n",p1.name,p1.age,p1.sex,p1.address)

	//2.方法二
	p2:=Person{}
	p2.name="Ruby"
	p2.age=28
	p2.sex="女"
	p2.address="上海市"
	fmt.Printf("姓名·：%s,年龄：%d,性别：%s,地址：%s\n",p2.name,p2.age,p2.sex,p2.address)

   //3.方法三
   p3:=Person{name:"如花",age:20,sex:"woman",address:"Hangzhou"}
   fmt.Println(p3)
   p4:=Person{
	   name:"隔壁老王",
	   age:40,
	   sex:"男",
	   address:"武汉市",
   }
   fmt.Println(p4)

 //4.方法四
 p5:=Person{name:"李小花",age:18,sex:"woman",address:"深圳"}
 fmt.Println(p5)
}
//1.定义结构体
type Person struct {
	name string
	age int
	sex string
	address string
}

结构体是值类型：

p1:=Person2{"王二狗",30,"man","Beijing"}
    fmt.Println(p1)
	fmt.Printf("%p,%T\n",&p1,p1)

	p2:=p1
	fmt.Println(p2)
	fmt.Printf("%p,%T\n",&p2,p2)

	p2.name="李小花"
    fmt.Println(p2)
	fmt.Println(p1)

定义结构体指针：

var pp1 *Person2
	pp1 =&p1
	fmt.Println(pp1)
	fmt.Printf("%p,%T\n",pp1,pp1)
	fmt.Println(*pp1)


	//(*pp1).name="李四"
	pp1.name="王五"
	fmt.Println(pp1)
	fmt.Println(p1)

Go语言不是面向对象的语言，没有封装，继承，多态三大属性。
但是Go语言的结构体嵌套可以模拟继承，聚合关系。代码示例：

func main() {
/*
	面向对象：oop
	Go语言中结构体嵌套：
	     1.模拟继承性：is-a
	      type A struct{
	             field
	}
	type B struct{
	A //匿名字段
	}
	2.模拟聚合关系
	     has-a
	type C struct{
	field
	}
	type D Struct{
	c C

	*/
	//1.创建父类的对象
	p1:=Person1{name:"张三",age:30}
	fmt.Println(p1)
	fmt.Println(p1.name,p1.age)

	//2.创建子类对象
	s1:=Student3{Person1{"李四",17},"千峰教育"}
	fmt.Println(s1)

	s2:=Student3{Person1:Person1{name: "rose",age:19},school: "北京大学"}
	fmt.Println(s2)

	var s3 Student3
	s3.Person1.name="王五"
	s3.Person1.age=18
	s3.school="清华大学"
	fmt.Println(s3)

    s3.name="Ruby"
	s3.age=16
	fmt.Println(s3)

	fmt.Println(s1.name,s1.age,s1.school)
	fmt.Println(s2.name,s2.age,s2.school)
	fmt.Println(s3.name,s3.age,s3.school)

	/*
	s3.Person.name

	*/
}
//1.定义父类
type Person1 struct {
	name string
	age int
}
//2.定义子类
type Student3 struct {
	Person1 //模拟继承结构
	school string//子类的新增属性

}

主要了解面向对象的思想，主要是掌握结构体的两种嵌套。