DAY05:指针；值类型和引用类型；标识符；关键字；运算符

指针

基本介绍

1. 基本数据类型，变量存的就是值，也叫值类型

2. 获取变量的地址，用&，比如: var num int，获取 num 的地址: &num分析一下基本数据类型在内存的布局.

3. 指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值

4. 获取指针类型所指向的值，使用:*，比如: var ptr int,使用ptr 获取 ptr 指向的值

package main

import "fmt"

func main() {
	var num = 1
	fmt.Printf("num的地址值%v", &num)
	// 取num的地址值
	var ptr *int = &num
	fmt.Printf("\nptr的值%v", ptr)
	// 通过指针获取num的值
	fmt.Printf("\nnum的值%v", *ptr)
}

练习

1. 写一个程序，获取一个 int 变量 num 的地址，并显示到终端

2. 将 num 的地址赋给指针 ptr，并通过 ptr 去修改 num 的值

package main

import "fmt"

func main() {
	var num = 1
	fmt.Printf("\ni的值=%v", num)
	var ptr *int = &num
	fmt.Printf("\nptr的值=%v", ptr)
	*ptr = 8
        // num = *ptr + 8
	fmt.Printf("\nnum修改后的值=%v", num)
}

注意事项

1. 值类型，都有对应的指针类型，形式为*数据类型，比如 int 的对应的指针就是 int,float32对应的指针类型就是float32、依次类推。

2. 值类型包括:基本数据类型 int 系列,float 系列,bool,string 、数组和结构体 struct

值类型和引用类型

分类

1. 值类型:基本数据类型 int 系,float 系列,bool,string 、数组和结构体 struct

2. 引用类型: 指针、slice 切片、map、管道 chan、interface 等都是引用类型

特点

1. 值类型:变量直接存储值，内存通常在栈中分配

2. 引用类型:变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由 GC 来回收

标识符

基本介绍

1. Golang 对各种变量、方法、函数等命名时使用的字符序列称为标识符

2. 凡是自己可以起名字的地方都叫标识符

命名规范

1. 由 26 个英文字母大小写，0-9 ，-组成

2. 数字不可以开头。var num int //ok var 3num int //error

3. Golang 中严格区分大小写。

4. var num int

5. var Num int

6. 说明:在 golang 中，num 和 Num 是两个不同的

7. 变量标识符不能包含空格。

8. 下划线""本身在 Go 中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如: 忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用

9. 不能以系统保留关键字作为标识符 (一共有 25 个)，比如 break，if 等等

注意事项

1. 包名: 保持 package 的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突 fmt

2. 变量名、函数名、常量名: 采用驼峰法

3. 如果变量名、函数名、常量名首字母大写，则可以被其他的包访问; 如果首字母小写，则只能在本包中使用( 注:可以简单的理解成，首字母大写是公开的，首字母小写是私有的),在 golang 没有public ,private 等关键字。

package main

import (
	// 引入相对应的包  GOPATH + src 是默认的路径
	"day04/test/importTest/model"
	"fmt"
)

func main() {
	fmt.Printf("引入的值=%v", model.Name)
}

目录结构和

系统保留关键字

在Go中，为了简化代码编译过程中对代码的解析，其定义的保留关键字只有25个。详见如下

关键字

系统预定义标识符

除了保留关键字外，Go还提供了36个预定的标识符，其包括基础数据类型和系统内嵌函数

预定义标识符

运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

1. 算术运算符

2. 赋值运算符

3. 比较运算符/关系运算符

4. 辑运算符

5. 位运算符

6. 其它运算符

算术运算符

算术运算符

注意事项

1. 对于除号，它的整数除和小数除是有区别的: 整数之间做除法时，只保留整数部分而舍弃小数部分。 例如: x := 19/5,结果是 3

2. 当对一个数取模时，可以等价 a%b=a-a/b*b ，这样我们可以看到 取模的一个本质运算。

3. Golang 的自增自减只能当做一个独立语言使用时，不能这样使用

4. Golang 的++ 和 -- 只能写在变量的后面，不能写在变量的前面，即: 只有 a++ a-- 没有 ++a

5. Golang 的设计者去掉 c /java 中的 自增自减的容易混淆的写法,让 Golang 更加简洁,统一。(强制性的)

package main

import "fmt"

func main() {

	// 只保留证数部分
	var num int = 10 / 4
	var num2 float64 = 10 / 4
	// 要想保留小数必须有小数参与运算
	var num3 float64 = 10.0 / 4
	fmt.Printf("\nnum的值=%v", num)
	fmt.Printf("\nnum2的值=%v", num2)
	fmt.Printf("\nnum3的值=%v", num3)

	// 取模的使用
	fmt.Printf("\n取模的使用%v", 10%4)

	// go中只有 i++ i--的写法并且只能独立使用
	var i = 1
	i++
	fmt.Printf("\ni的值=%v", i)

}

练习

1. 假如还有 97 天放假，问: xx 个星期零 xx 天

2. 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为: 5/9*(华氏温度-100).请求出华氏温度对应的摄氏温度。

package main

import "fmt"

func main() {
	// 假如还有 97 天放假，问: xx 个星期零 xx 天
	var day = 97
	var fireWeek = day / 7
	var fireDay = day % 7
	fmt.Printf("剩余假期%v个星期零%v天", fireWeek, fireDay)
	// 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为: 5/9*(华氏温度-100).请求出华氏温度对应的摄氏温度。
	var huashe = 134.2
	var sheshi = 5.0 / 9 * (huashe - 100)
	fmt.Printf("\n%v对应%v\n", huashe, sheshi)
}

关系运算符（比较运算符）

基本介绍

1. 关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false

2. 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

关系运算符

注意事项

1. 关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false。

2. 关系运算符组成的表达式，我们称为关系表达式: a> b

3. 比较运算符"=="不能误写成“=”

package main

import "fmt"

func main() {
	var n1 = 9
	var n2 = 10
	fmt.Println(n1 == n2)
	fmt.Println(n1 != n2)
	fmt.Println(n1 > n2)
	fmt.Println(n1 >= n2)
	fmt.Println(n1 < n2)
	fmt.Println(n1 <= n2)
	flag := n1 > n2
	fmt.Println(flag)
}

逻辑运算符

基本介绍

用于连接多个条件 (一般来讲就是关系表达式) ，最终的结果也是一个 bool 值

逻辑运算符

package main

import "fmt"

func main() {
	var age = 40
	if age > 30 && age < 50 {
		fmt.Println("ok1")
	}
	if age > 30 && age < 40 {
		fmt.Println("ok2")
	}
	if age > 30 || age < 50 {
		fmt.Println("ok3")
	}
	if age > 30 || age < 40 {
		fmt.Println("ok4")
	}
	if age > 30 {
		fmt.Println("ok5")
	}
	if !(age > 30) {
		fmt.Println("ok6")
	}
}

注意事项

1. &&也叫短路与: 如果第一个条件为 false，则第二个条件不会判断，最终结果为 false

2. ||也叫短路或:如果第一个条件为 true，则第二个条件不会判断，最终结果为 true

package main

import "fmt"

func test() bool {
	fmt.Println("进入test")
	return true
}

func main() {
	var i = 10
	if i > 9 && test() {
		fmt.Println("ok")
	}
	if i > 9 || test() {
		fmt.Printf("ok2")
	}
}

赋值运算符

基本介绍

赋值运算符就是将某个运算后的值，赋给指定的变量。

添加图片注释，不超过 140 字（可选）

注意：这部分的赋值运算涉及到二进制相关知识

添加图片注释，不超过 140 字（可选）

注意事项

1. 运算顺序从右往左

2. 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值

3. 复合赋值运算符等价于下面的效果，比如: a+=3 等价于 a=a+ 3

package main

import "fmt"

func main() {
	// 普通赋值
	var i int
	i = 1
	fmt.Println(i)
	// +=赋值
	i += 2
	fmt.Println(i)
	// 运算符号作便可以实变量 表达式  标量值
	var n = 1
	n = i
	n = 1 + 1
	fmt.Println(n)
}

练习1

有两个变量，a和，要求将其进行交换，最终打印结果

package main

import "fmt"

func main() {
	var n1 = 10
	var n2 = 20
	var n3 int
	n3 = n1
	n1 = n2
	n2 = n3
	fmt.Printf("交换后的n1=%v,n2=%v", n1, n2)
}

练习2

有两个变量，a 和 b，要求将其进行交换，但是不允许使用中间变量，最终打印结果

package main

import "fmt"

func main() {
	var n1 = 10
	var n2 = 20
	n1 = n1 + n2
	n2 = n1 - n2 // n2 = n1 + n2 - n2 ==> n2 = n1
	n1 = n1 - n2 // n1 = n1 + n2 - n1 ==> n1 - n2
	fmt.Printf("交换后的n1=%v,n2=%v", n1, n2)
}

位运算符

位运算符

其他运算符

其他运算符

package main

import "fmt"

func main() {
	var num int = 10
	fmt.Println("num的地址=", &num)

	var ptr *int = &num
	fmt.Println("prt指向的值=", *ptr)
}

特别说明

golang中没有三元表达式

运算符执行优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。

运算优先级

综合练习

求两个数的最大值

package main

import "fmt"

func main() {
	var num1 = 10
	var num2 = 20

	var num3 int

	if num1 > num2 {
		num3 = num1
	} else {
		num3 = num2
	}

	fmt.Println("最大值=", num3)
}

求三个数的最大值

package main

import "fmt"

func main() {
	var num1 = 10
	var num2 = 20
	var num4 = 30

	var num3 int
	// 先求出两个值的最大值
	if num1 > num2 {
		num3 = num1
	} else {
		num3 = num2
	}
	// 在比较剩余两值的最大值
	if num4 > num3 {
		num3 = num4
	}
	fmt.Println("最大值=", num3)
}