【GO】基础速成

基础速成"/>

【GO】基础速成

简单介绍一下go好处

• 编译语言，可以提前报错
• 同时又有python的一些优点，
• 自带多线程

开始学习

学习网站：学习网站

值

包含：字符串、整型、浮点型、布尔型等等
字符串可以 + 进行拼接。
需要注意的是布尔型在go里面不自动转化为int类型，不认为 true为1 false为0。布尔型是布尔型，int类型就是int类型，不可以转化

变量与常量

// 正常声明变量
// var关键字，表示要声明变量，后面加变量名
// 变量名之后加变量类型
// 最后附上初始化的值
var a int = 1
// 省略版声明变量
// 但只能作为局部变量
// 并且必须初始化
// 会自动根据初始化的值为变量设置类型
b := 1// 能var的地方就能const
// 数值型常量没有确定的类型，直到被给定某个类型，比如显式类型转化。
const n = 123

循环

// 好像只有for 循环
// while的写法
i := 1
for i <= 3 {i = i + 1
}// 正常for写法
for i := 0; i <= 2 ; i ++{//
}// 死循环
// 只能break掉
// 支持break 与 continue语句
for {
}

if-else & switch

// 没啥好说的
if 7%2 == 0 {} else if  condition {} else {}// switch 有些不一样
// c会继续自动往下执行
// go是你必须显示说明语句才会往下一个case执行
// 所以不需要添加break语句
switch i {
case 1:// 1干啥
case 2:// 2干啥
default:// 最后一个情况干啥
}

数组

一般不用数组，因为跟C数组一样，固定死，不能动态改变

	var a [5]intb := [5]int{1, 2, 3, 4, 5}c := len(b)

高级数组slice

一般用这个，类似vector的东西吧

// 声明一个slice
// make语句，第一个表示类型，第二个表示个数
s := make([]string, 3)
// 支持len()检测长度
// 支持copy
// 支持append
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("apd:", s)
c := make([]string, len(s))
copy(c, s)
fmt.Println("cpy:", c)

map

// map声明
// 使用make，中括号里面写key的type
// 后面跟上value的type
m := make(map[string]int)

range

类似for-each

nums := []int{2,3,4}
sum := 0
// 遍历数组，slice类似
// 第一个返回下标，第二个返回值
for i, num := range nums{sum += num
}// 遍历map
// 第一个返回key, 第二个返回value
m := make(map[string]int)
for key, value := range m {
}

函数

变量数组这些声明都挺抽象的，函数声明更抽象

// func关键字表示要声明一个函数
// 后面跟函数名
// 后面跟形参，先形参名后面跟类型
// 形参写完最后写函数返回值的类型，可以多个
// 够抽象吧？
func plus(a int, b int) int {return a+b
} // 多返回值
func mul(a int, b int) (int, int){return 3,7
}// 这是对的方式
func xxxx {}// 这个是错的方式
func xxx
{}

还有一个需要极其注意的点是，go语言可以不加封号，是因为在编译时候编译器会帮你加上
前提是你括号写的方式要写对

// 变参函数，也就是说可以输入参数个数不固定，也可以是数组
func sum(nums ...int) {fmt.Print(nums, " ")total := 0for _, num := range nums {total += num}fmt.Println(total)
}
func main(){sum(1,2)sum(1,2,3)nums := []int{1,2,3,4}sum(nums...)
}

指针

没想到吧？go这沙比还支持指针，而且这个指针跟c感觉差不多。感觉这个语言是个缝合怪

// 直接copy了
package mainimport "fmt"func zeroval(ival int) {ival = 0
}func zeroptr(iptr *int) {*iptr = 0
}func main() {i := 1fmt.Println("initial:", i)zeroval(i)fmt.Println("zeroval:", i)zeroptr(&i)fmt.Println("zeroptr:", i)fmt.Println("pointer:", &i)
}// 最后的result
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100

结构体

// 结构体声明
// type struct关键字中间加结构体名称
// 里面写成员变量
// 先名称后类型
type person struct {name stringage int
}// struct好像没有构造函数
// 所以好像一般使用类似工厂模式写一个方法
// 感觉有点呆
func newPerson(name string, age int) *person {
// 构造结构体对象的各个方法// 1.按照顺序默认对应p := person{name, age}// 2.指明赋值p := person{name: name, age: age}// 返回指针return &p
}func main(){s := newPerson("Bob", 23)// 还有一个点跟C有点不一样// go的.运算符可以自动解指针，不需要加*了fmt.Println(s.age)
}// go 可以对结构体编写成员函数
// func 后面跟括号，里面第一个写变量名 第二个写类型
// 一般要写成指针形式，不然调用函数修改的是你这个对象的拷贝
// 第一个变量就是调用自己这个实例，类似于this或者self
// 所以如果习惯java可以第一个叫this，习惯python可以写self
// 可以自己去试试看
// 加了这一项表名这个方法是person的成员函数
// 由于set方法不需要返回值，所以参数列表之后为空
func (p *person) setAge(age int) {p.age = age
}

后面接口啥的就不写了，差不多到这基本大体上写写一般程序够用了。
面向对象还要学学继承跟多态，GO语言这两个有点抽象
摆烂先懒得写，后面补

继承

哥们回来补作业啦
go的继承比较奇怪，他不用JAVA或者python那种显示关键字进行继承，而是用组合

// 先说说go语言特性
// 在struct可以编写匿名字段
// 也就是说不写名称，只写类型
// 但每一个struct的一个类型只能有一个匿名
type demo struct{intfloat32
}
d := demo{}
// 直接这样就可以访问匿名字段
d.int// 再说说“继承”也就是组合
type Animal struct {
}func (self *Animal) Eat() {fmt.Println("Animal eating....")
}type Cat struct {// 这里直接用匿名// 是为了如果需要访问父类// 只需要.Animal就行// 不然到时候起个名字// 调用父类还都是乱七八糟的名字Animal
}// 重写方法
func (self *Cat) Eat() {// 这里就可以通过组合访问父类的字段// 或者方法// 这里其实就有点类似于java的superself.Animal.Eat()fmt.Println("Cat eating...")
}// go在调用方法时候会自己判断
// 有没有重写方法
// 有就调用最新的
// 没有就调用父类的
// 自己试试
func main() {cat := Cat{}cat.Eat()
}

接口

go的接口好像比较简单一些些，就弄个接口，没有什么显示的关键字关联关系，只要实现了这个接口里面的所有方法，就算实现了这个接口，完了就可以用接口实现多态。
go好像不用继承实现多态？我不懂是不是这样，有懂哥麻烦评论区说说呗？感激不尽。

// 写个接口creature
// 接口俩方法一个叫一个跑
type creature interface {run() stringsound() string
}type Cat struct{}
type Human struct{}// 猫实现接口俩方法
func (self *Cat) run() string {return "Cat running..."
}func (self *Cat) sound() string {return "miao~"
}// 人实现接口俩方法
func (self *Human) run() string {return "Human running..."
}func (self *Human) sound() string {return "wocao!"
}func main() {// 完了之后开个接口类型切片// 初始化一下c := make([]creature, 2)c[0] = &Cat{}c[1] = &Human{}// 发现可以实现多态for _, v := range c {fmt.Println(v.run())fmt.Println(v.sound())}
}

完了之后还有一个空接口，interface{}。这玩意类似java的obj。谁都是他的子类就这么理解应该就行了。
所以参数里面写interface{}这个类型就说明他可以接收任意类型的参数。
那么如何动态的检测这个interface{}类型具体是什么类型呢？

// 用这个类型断言机制
func main() {// 声明a为interface类型，并且初始化为一个stringvar a interface{}a = "i am a string"// 这个变量名.再加括号里面加类型就是类型断言// 返回值有两个// 第一个是类型断言之后的值// 第二个表示是否是这个类型v, err := a.(string)if err != false {fmt.Println(v)} else {fmt.Println("im not string")}// 还有一个是变量名.(type)返回的只有一个值，是这个变量的具体类型// 但必须结合switch语句进行使用// copy 别人代码switch v := x.(type) {case string:fmt.Printf("x is a string，value is %v\n", v)case int:fmt.Printf("x is a int is %v\n", v)case bool:fmt.Printf("x is a bool is %v\n", v)default:fmt.Println("unsupport type！")}

好了更完了继承接口多态。就可以去写OOP了。
继续鸽。
还没到GO最特别的，也就是并发那一块跟channel。
继续摆，过几天再学再写写