golang学习笔记06

如何声明结构体：

基本语法：

type 结构体名称 struct{
    field1 type
    field2 type
}

举例：

type Student struct{
    Name string
    Age int
    Score float64
}

字段\属性

基本介绍：

1. 从概念或叫法来看：结构体字段 = 属性 = field
2. 字段是结构体的一个组成部分，一般是基本数据类型、数组，也可以是应用类型。

注意事项和细节说明：

1. 字段声明语法同变量：基本语法： 字段名 字段类型（ name string ）
2. 字段的类型可以是基本类型和引用类型

指针、map、slice、初始值都是nil，一开始需要分配空间

type Persion struct{
    heros map[string]map[string]string
    slice []int
}
func main(){
	var p1 Persion
    p1.heros = make(map[string]map[string]string)
	p1.heros["齐天大圣"] = make(map[string]string,2)
	p1.heros["齐天大圣"]["skill"] = "火眼晶晶"
	p1.heros["齐天大圣"]["age"] = "7500"

	p1.heros = make(map[string]map[string]string)
	p1.heros["牛魔王"] = make(map[string]string,2)
	p1.heros["牛魔王"]["skill"] = "芭蕉扇"
	p1.heros["牛魔王"]["age"] = "6500"

	fmt.Println(p1.heros)
    p1.slice = make([]int,5,6)
	p1.slice[4] = 10
	fmt.Println(p1.slice)
}

创建结构体变量和访问结构体字段

type Persion struct{
    Name string
    Age int
}
1.
var persion Persion
2.var persion Persion = Persion{"marry",15}
//相当于定义了：persion.Age = 15
//persion.Name = "marry"
3.
var persion *Persion = new (Persion)//返回的是一个指针，一个Persion结构体的指针
//后续可以接着用指针来赋值
4.
var persion *Persion = &Persion{"marry",18}

3和4 都是进行了指针的引用，返回的是一个指针。

方法：

定义：

在某些情况下，我们需要声明（定义）方法，比如Persion结构体，除了有一些字段外（年龄、姓名…）Persion还有一些行为、一些功能；

另外，golang中方法是作用与指定的数据类型上的，因此自定义类型，都有方法，而不仅仅是struct

方法的声明和调用：

type A struct{
    Num int
} 
func (a A) test1(){
    fmt.Println(a.Num)
}

• func (a A) test1() { }表示A结构体有一种方法，方法名叫做test
• (a A)体现test 方法是和A类型绑定的
• 与A类型绑定后，只能由A类型变量来调用

快速入门：

package main
import "fmt"
type MethodUtils struct{
	arr [3][3]int
}//字段是一个数组
func (mu MethodUtils) fun(n1 int){
	for i:=1;i<=n1;i++{
		for j:=1;j<=i;j++{	
			fmt.Printf("%d*%d=%d\t",j,i,j*i)
		}
		fmt.Println()
	}//接收n1一个整数，乘法口诀表直到n1
}
func (mu *MethodUtils) fun2(){
	for index ,_:=range mu.arr{
		fmt.Println(mu.arr[index])
	}
	var arr2 [3][3]int
	arr2 = mu.arr
	for i:=0;i<3;i++{
		for j:=0;j<3;j++{
			mu.arr[i][j] = arr2[j][i]
		}
	}
}//方法使得二维数组变换矩形
func main(){
	var mu MethodUtils
	mu.fun(9)
	var mu1 MethodUtils
	for i:=0;i<3;i++{
		for j:=0;j<3;j++{
			fmt.Scan(&mu1.arr[i][j])
		}
	}
	mu1.fun2()
	for index ,_:=range mu1.arr{
		fmt.Println(mu1.arr[index])
	}
}//主方法，调用

方法的声明：

func (recevier type) meyhoName(参数列表) (返回值列表){
    方法体
    return 返回值    
}

• receiver type ：表示这个方法和type这个类型进行了绑定，或者说该方法用于type类型
• receiver type 可以是结构体也可以是其他自定义的类型
• 返回值和普通函数相同可以有多个返回值
• return语句不是必须的

方法的注意事项和和细节

1. 结构体类型是值类型，遵循的是值类型传递机制，是值拷贝传递机制
2. 如果程序元希望在方法中，修改结构体的值，可以通过结构体指针的方式来处理
3. golang中的方法作用在指定的数据类型上的，因此自定义类型都可以有方法，而不仅仅是struct，比如int 、float64

type integer int
func (n1 *integer) change(){
    *n1 = *n1 + 1
}
func main(){  
    var i integer = 10
    i.change()
    fmt.Println(i)//此时输出的是11而不是10，因为用了指针，进行了改变
}

方法和函数不同

1）调用的方式不相同

函数的调用方式为： 函数名（实参列表）

方法的调用方式： 变量.方法名（实参列表）

2）

对于普通的函数，接收为值类型，不能用引用类型数据直接传递，相反也一样

对于方法，接收为值类型，但是可以用引用类型调用，接收为指针类型也可以用值类型，最终的调用方式是方法的的类型。

面向对象编程的引用实例：

步骤：

1）声明结构体变量，确定结构体名

2）编写结构体字段

3）编写结构体方法

学生与狗的案例

package main
import (
	"fmt"
)
type Student struct{
	name string
	gender string
	age int
	scores float64
}//定义一个Student结构体
type Dog struct{
	name string
	age int
	weight float64
}//Dog 结构体
func (dog *Dog) say(){
	fmt.Printf("dog的信息:\nname = %s\nage = %d\nweight =%f",
		dog.name,dog.age,dog.weight)

}//与Dog相绑定的方法say

func (stu *Student) say(){
	fmt.Printf("student的信息为 ：\n"+
		"姓名 ：%v\ngender : %v\n"+
		"age = %d\nscores = %.1f",stu.name,stu.gender,stu.age,stu.scores)
}//与Student相绑定的say方法

func main(){
	var stu = Student{
		name :"小明",
		age : 15,
		gender : "男",
		scores : 83.3,
	}//上面是stu，下面是dog的声明
	stu.say()
	fmt.Println()
	var dog Dog = Dog {
		name : "强子",
		age : 15,
		weight : 15.3,
	}
	dog.say()
}

景区门票案例

1）根据年龄收取不同价格的门票，比如年纪>18，收取20，其他情况免费，

2）编写Visitors结构体，根据年龄来决定收取门票价格并输出

3）代码：

package main

import "fmt"

type Visitors struct{
	Name string
	Age int
}

//func (v *Visitors) GetPrice(){
//	if v.Age>=70{
//		fmt.Println("您的年龄过大，不是适合玩此游戏")
//	}
//	if v.Age>=18&&v.Age<=70{
//		fmt.Printf("姓名：%s\n价格： 20",v.Name)
//	}else{
//		fmt.Printf("姓名：%s\n价格： 免费",v.Name)
//	}
//}
//
//func main(){
//	var v1 Visitors
//	fmt.Println("请输入您的姓名...")
//	fmt.Scanln(&v1.Name)
//	fmt.Println("请输入您的年龄...")
//	fmt.Scanln(&v1.Age)
//	v1.GetPrice()
//}
func (v *Visitors) GetPrice(){
	if v.Age>=70{
		fmt.Println("您的年龄过大，不是适合玩此游戏")
		return
	}
	if v.Age>=18&&v.Age<=70{
		fmt.Printf("姓名：%s\n价格： 20\n",v.Name)
	}else{
		fmt.Printf("姓名：%s\n价格： 免费\n",v.Name)
	}
}
func main(){
	var v Visitors
	for{
		fmt.Println("您的姓名：(按\"n\"退出程序)")
		fmt.Scanln(&v.Name)
		if v.Name == "n"{
			fmt.Println("退出程序...")
			break
		}
		fmt.Println("您的年龄：")
		fmt.Scanln(&v.Age)
		v.GetPrice()
	}
}

创建结构体变量时，指定字段值

• 说明：

golang在创建结构体时是可以直接指定字段的值的

方式一：
var stu1 = Stu{"mary",18}
方式二：
var stu2 = Stu{
    Name : "jack",
    Age :18
}此种方法可以不与结构体字段顺序匹配
方法三：
var stu3 = &Stu{
    Name : "simth"
    Age : 89
}//返回的是一个结构体指针变量