指针，以及标识符
1.指针
（1）.基本介绍
1）基本数据类型，变量存的值，也叫值类型
2）获取变量的地址用&，比如 var num int ,获取num的地址：&num
3)指针类型，变量存的是一个地址，这个地址指向的空间存的才是真正值，比如： var ptr *int =&num
4)获取指针类型所指的值，使用*,比如：var *ptr int,使用 *ptr获取p指向的值
5）举例说明
package main
import(
"fmt"
)
//演示golang中的指针类型
func main(){
//基本数据在内存的布局
var i int = 10
// i的地址是多少 &i
fmt.Println("i的地址=",&i) //结果为：i的地址= 0xc04205e058
//1.a是一个指针变量
//2. a的类型是 *int
//3.a 本身就是 &i
var a *int =&i
fmt.Println("i的值是",i) //10
fmt.Println("a存放的值是",a)//0xc04205e058
fmt.Println("a指向的值是",*a)//10
fmt.Println("指针本身的地址是",&a)//0xc04207c020
或者可以使用printf()进行格式化输出
}
内存布局图：
关于指针的内存布局操作
练习，通过指针修改所存变量地址中存放的值
package main
import(
"fmt"
)
func main(){
var a int =999
fmt.Println("a的地址是",&a)
fmt.Println("指针修改之前a的值是",a)
var prt *int = &a
fmt.Println("prt的值是",*prt)
*prt = 23 //通过指针去修改a变量的值
fmt.Println("prt的值是",*prt)
fmt.Println("通过指针修改后这个a的值是",a)
}
判断对错
func main(){
var a int = 300
var ptr *int =a //错误应该是 &a
}
func main(){
var a int = 300
var prt *float32 = &a //错误，类型不一致，不应该是float
}
func main(){
var a int =300
var b int =400
var ptr *int =&a
*ptr = 100 //a=100
ptr = &b //存放b的地址
*ptr = 200 //b=200
fmt.Printf("a=%d, b=%d,*ptr=%d",a,b,*ptr)
}
（2）指针的细节说明
1)值类型，都有对应的指针类型，形式为：“数据类型”，比如int 的对应的指针就是 * int,而float32对应的指针类型就是 *float32 ,以此类推
2)值类型：基本数据类型int系列，float系列，bool string \数组和结构体struct
2.值类型和引用类型
（1）说明：
1)值类型:基本数据类型int系列，float系列，bootl,string、数组和结构体struct
2)引用类型：指针，slice切片、map、管道chan,interface等都是引用类型
（2）值类型和引用类型的区别
1）值类型：变量直接存储，内存通常在栈中分配
2）引用类型：变量存储的是一个地址，这个地址对应的空间才真正存储数据（值），内存通常在堆中分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾由GC来回收
3.标识符的命名规范
（1）.标识符概念
1）golang对各种变量、方法等命名时使用的字符序列称为标识符
2）凡是自己可以起名字的地方都叫标识符
（2）.标识符的命名规则(6点)
1）由26个英文字母大小写，0~9，下划线—组成
2）数字不可以开头
3）Golang中严格区分大小写
4）标识符不能包含空格
5）下划线"—"本身在go中是一个特殊字符，称为空标识符，可以代表任何其他的标识符，但是它对应的值会忽略（比如，忽略某个返回值），所以仅能被作为占位符使用不能作为标识符使用
6）不能以系统保留关键字作为标识符，比如break、if等等…
package main
import "fmt"
//演示golang中标识符的使用
func main() {
//严格区分大小写
var num int = 10
var Num int = 20
fmt.Printf("num=%v,Num=%v",num,Num) //10 20
//标识符中不能含有空格
// var ab c int = 30 //会报错
//_是空标识符，用于占用
// var _ int =40 // erro
}
（3）go中的保留字
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cm24KPYQ-1693040914579)(D:\myfile\后端\go语言学习\pic\关键字.jpg)]
标识符的案例
hello //OK
hello12 //OK
1hello //erro 不能以数字开头
h-b //erro 不能使用-
x h //erro 不能有空格
h_4 //ok
_ab //ok
int //ok 不推荐，甚至不要去用,语法通过不推荐使用
var int int =10
fmt.Println("int的值",int)//10success
float32 //ok
_ //erro
Abc //ok
（4）标识符命名注意事项
1）包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义不要和标准库冲突
2）变量名、函数名、常量名，采用驼峰法
var stuName string ="Tom"
var goodPrice int32 =124//第一个单词字母小写往后的单词采用大写的形式
3）如果使用变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用（可以简单理解成，首字母大写是公有的，首字母小写是私有的）
预定标识符
保留关键字的介绍：
（5）运算符：
运算符是一种特殊的符号，用以表示数据的运算，赋值和比较等
1）算术运算符
主要是对数值型的变量进行运算，比如加减乘除，在Go程序中使用最多
package main
import(
"fmt"
)
func main() {
//重点讲解 /,%
//如果参与运算的数都是整数，那么除后，去掉小数部分，保留整数部分。不会四舍五入
fmt.Println(10/4) //是2不是2.5
var n1 float32 = 10 /4 //?结果也是2
fmt.Println(n1)
//如果我们需要保留小数部分，则需要有浮点数参与运算
var n2 float32 = 10.0 /4
fmt.Println(n2) //2.5
}
//演示%的用法
//演示 % 的使用
//看一个公式 a%b=a - (a/b) *b
fmt.Println("10%3=",10 % 3) //结果余数是1
fmt.Println("-10%3=",-10 % 3) //结果余数是-1 : -10 - [(-10)/3]*3 =-10 -(-9)=-1
fmt.Println("10%-3=",10 % -3) //结果余数是 1
fmt.Println("-10%-3=",-10 % -3) //结果余数是 -1
//演示 ++ --
var i int = 10
i++ //等价 i = i+1
fmt. Println("i的值是",i) //11
i-- //等价i = i -1
fmt. Println("i的值是",i) //10
（6）细节说明：
1）对于除号 ”/“，他的整数和小数除是有区别的，整数之间做除法时，只保留整数部分而舍弃小数部分，例如 x := 19/5 结果是3
2）当对一个数取模式时，可以等价 a%b =a- a/b *b,这样我们就可以看到取模的本质运算
3）Golang的自增自减只能作为一个独立语言时，不能这样使用 b :=a++或者b :=a–
4）Golang的++和–只能写在变量的后面，不能写在变量的前面，既：a++ a–没有++a 或者–a
5）Golang的设计者去掉c/java中的自增自减的容易混淆的写法让Golang的语法更加简洁统一
练习：
（1）假如还有97天放假 问 xx个星期零xx天
（2）定义一个变量保存华氏温度，华氏温度转换为摄氏温度的公式是：5/9*(华氏温度-100)求出华氏温度对应的摄氏温度
package main
import (
"fmt"
)
func main(){
//题1
var day int =97
var week int = day/7
var mo int = day%7
fmt.Printf("还有%d天放假,是%d个星期%d天",day,week,mo)
var huashi float32 = 134.2
var sheshi float32 = 5.0 / 9 * (huashi - 100)
fmt.Printf("%v对应的摄氏温度=%v",huashi,sheshi) 19
}
2）赋值运算符
介绍
赋值运算符就是将某个运算后的值，赋给指定的变量
赋值运算符的分类：
案例演示
（1）赋值基本案例
（2）有两个变量，a和b ，要求将其交换，最终打印结果
（3）+=的使用案例
package main
import (
"fmt"
)
func main() {
//赋值运算符的使用演示
// var i int
// i = 10 //基本赋值
//有两个变量，a和b要求将其进行交换，最终打印结果
//a =9 b=2 ==>a =2 b =9
a := 9
b := 2
//定义一个临时变量
t :=a
a =b
b =t
fmt.Printf("交换后的情况如下 a=%v,b=%v",a,b)
//复和赋值的操作
a +=7 //等价 a = a+7
fmt.Println("a+=7的值为",a)
}
赋值运算符的特点
（1）运算顺序从右往左
（2）赋值运算符的左边只能是变量 ，右边 可以是变量、表达式、常量值
（3）复合运算符等价于下面的效果
a+=3 a=a+3
3）比较运算符/关系运算符
(1)关系运算符的结果都是bool型，也就是要么为true,要么为false
(2)关系表达式经常用字在if结构中或者循环条件中
关系运算符一览表
细节说明
- 关系运算符的结果都是bool型，也就是要么为true,要么为false
- 关系运算符组成的表达式，我们称为关系表达式 a>b
- 比较运算符”==“不能写成 “=”
面试题
package main
import(
"fmt"
)
func main(){
//有两个变量a和b，要求将其进行交换，但是不允许使用中间变量，最终打印效果
var a int = 10
var b int = 20
a = a + b //30
b = a - b // 10
a = a -b //30-10 =20
fmt.Printf("a=%v和b=%v",a,b) //20 和 10
}
4）逻辑运算符
介绍
用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个bool值
逻辑运算一览表：
案例演示
package main
import (
"fmt"
)
func main() {
//演示如何使用逻辑运算符
var age int =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") //不输出
}
}
注意事项和使用细节
- &&也叫短路与，如果第一个条件为false，则第二个条件不会判断，最终结果为false
- ||也叫短路或，如果第一个条件为true，则第二个条件不会判断，最终结果为true
案例演示：
//声明一个测试函数(测试)
func test() bool {
fmt.Println("test....")
return true
}
func main() {
var i int = 10
//短路与的
//说明：i<9 这个为false 第二条件根本不会去判断不会调用test函数
if i < 9 && test(){
fmt.Println("ok")
}
//短路或
//说明：i>9 这个为true 第二条件根本不会去判断不会调用test函数
if i > 9 || test(){
fmt.Println("ok")
}
运算符的优先级
（1）运算符有着不同的优先级，所谓优先级就是表达式运算中的运算顺序，如下表，上一行运算符总优先于下一行
（2）只有单目运算符、赋值运算符是从右往左运算的
（3）大致的顺序整理
- 括号，++.–
- 单目运算
- 算术运算符
- 移位运算
- 关系运算
- 位运算
- 逻辑运算符
- 赋值运算符
- 逗号
6）其他运算符
位运算符
课堂练习
（1）两个数的最大值
（2）求三个数的最大值
func main() {
//求两个数的最大值
var n1 int =10
var n2 int =40
var max int
if n1 > n2{
max =n1
}else{
max =n2
}
fmt.Println("两个数的最大值为：",max)
//求出三个数的最大值
//先求出两个数的最大值然后让第三个数取比较
var n3 int =45
if n3 > max {
max =n3
}
fmt.Println("三个数中的最大值是=",max)
}
键盘输入语句
介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取’
步骤：
1）导入fmt包
2）调用fmt包的fmt.Scanln()或者fmt.Scanf()
案例演示：
要求：可以从控制台上接受用户信息。[姓名，年龄，薪水,是否通过考试]
1）使用fmt.Scanln()获取
fmt.Println("请输入姓名")
//当程序执行到fmt.Scanln(name)是，程序会停止运行，并等待用户的输入
fmt.Scanln(&name)
fmt.Println("请输入年龄")
fmt.Scanln(&age)
fmt.Println("请输入薪水")
fmt.Scanln(&sal)
fmt.Println("是否通过考试")
fmt.Scanln(&isPass)
fmt.Printf("名字是%v \n 年龄是%v \n 薪水是 %v \n 是否通过考试 %v ",name,age,sal,isPass)
2）使用fmt.Scanf()获取
/方式2.一次性输入这些信息 fmt.Scanf()可以按指定的格式输入信息
fmt.Println("姓名，年龄，薪水，是否通过考试,输入时采用空格隔开")
fmt.Scanf("%s %d %f %t ",&name,&age,&sal,&isPass)
fmt.Printf("名字是%v \n 年龄是%v \n 薪水是 %v \n 是否通过考试 %v ",name,age,sal,isPass)
4.go语言机制转换
1）进制介绍
-
二进制 : 0,1 满2进1在golang中不能直接使用二进制表示一个整数，因为他沿袭了C语言的风格要输出就%b
-
十进制:0~9满10进1
-
八进制:0~7满8进1，以数字0开头表示
-
十六进制：0~9A-F满16进1以0x或0x开头表示
此处A~F不区分大小写
如：0x21AF+1=02x21B0
2)案例使用
func main(){
var i int =5;
fmt.Printf("%d的二进制是%b\n",i,i) //输出的结果是：5的二进制是101
//八进制：0~7，满8进1，以数字0开头进行表示
var j int = 011
fmt.Println("j=",j) //9
//0~9及A-F以0x或0X表示
var k int = 0x11
fmt.Println("k=",k) //17
}
进制转换的介绍
第一组（其他进制转换为十进制）
1）二进制转十进制
规则：从最低位开始（右边的），将每个位上的数提取出来，乘以2的（位数-1）次方然后求和
案例：请将二进制：1011转成十进制的数
1011=1*1+1*2+0*2*2+1*2*2*2=1+2+0+8=11
2）八进制转十进制
规则：从最低位开始（右边的），将每个位上的数提取出来，乘以8的（位数-1）次方然后求和
请将0123转成十进制的数
3+2*8+1*8*8=83
3）十六进制转十进制
规则：从最低位开始（右边的），将每个位上的数提取出来，乘以8的（位数-1）次方然后求和
请将0x34A转成十进制的数
10+4*16+3*16*16=842
第二组（十进制转其他进制）
1）十进制转二进制
规则：将该数不断除于2，直到商为0为止，然后将得到的余数倒过来就是对应的二进制
案例；请将56转成2进制
2）十进制转八进制
规则：将该数不断除于8，直到商为0为止，然后将得到的余数倒过来就是对应的二进制
3）十进制转十六进制
规则：将该数不断除于16，直到商为0为止，然后将得到的余数倒过来就是对应的二进制
第三组
1）二进制转八进制
规则：将二进制数每三位一组（从低位开始组合），转成对应的八进制数即可
案例将二进制 11010101转成八进制
11010101=0325
2）二进制转十六进制
规则：将二进制每四位数一组（从低位开始组合），转换对应的十六进制数即可
案例：请将二进制：11010101转成16进制数为：0XD5
11100101 转化为八进制：0345
1110010110转化为十六进制：0x396
第四组
1）将八进制数每1位转成对应的一个3位的二进制数即可
案例：请将0237转成二进制
0237=10011111
2)将十六进制每1位转成1个4位的二进制数
0x3D=0x111101
原码 补码反码
golang有三个位运算
2的补码：00000010
3的补码 00000011
2&3=00000010 =2
2|3=00000011=3
2^3=00000001
-2^2=-4
-2的原码为：10000010
-2的反码为：11111101
-2的补码：11111110
2的补码 00000010
故-2^2=11111100 的原码是先求出他的反码然后进行取反操作
反码=补码-1：11111011==》原码（符号位不变其他取反）：10000100=-4
-1：10000001=》反码=》11111110补码：11111111 +00000001=全是0
func main(){
//位运算的知识演示
fmt.Println(2&3) //2
fmt.Println(2|3)//3
fmt.Println(2^3)//1
//下面是带有负数的二进制
fmt.Println(-2^2)//-4
}
golang有两个移位运算符
>> 右移、 <<左移
右移运算符 >>:低位溢出，符号位不，并用符号位补溢出的高位
左移运算符<< 符号位不变，低位补0
案例演示：
都要将原来的数变成补码进行运算
a:=1>>2//00000001=>00000000=0 右移即补码左边补0
c:=1<<2 //00000001=>00000100=4左移即补码右边补0
fmt.Println(1>>2)//0
fmt.Println(1<<2)//4
…(img-EvonRpVt-1693040914591)]
2的补码：00000010
3的补码 00000011
2&3=00000010 =2
2|3=00000011=3
2^3=00000001
-2^2=-4
-2的原码为：10000010
-2的反码为：11111101
-2的补码：11111110
2的补码 00000010
故-2^2=11111100 的原码是先求出他的反码然后进行取反操作
反码=补码-1：11111011==》原码（符号位不变其他取反）：10000100=-4
-1：10000001=》反码=》11111110补码：11111111 +00000001=全是0
func main(){
//位运算的知识演示
fmt.Println(2&3) //2
fmt.Println(2|3)//3
fmt.Println(2^3)//1
//下面是带有负数的二进制
fmt.Println(-2^2)//-4
}
