一、切片类型
切片类型：是由数组建立的一种方便灵活的且功能强大的包装，切片本身不拥有任何数据类型，他只是对现有数组的引用。
即：指向了一个地址，本身不拥有数据。
package main import "fmt" func main() { //切片定义的第一种方式，由数组切出来 //var a [8]int=[8]int{1,2,3,4,5,6,7,8} ////只是对数组的引用 //var b []int=a[2:6] //fmt.Println(b) //a[2]=30 //fmt.Println(b) //b[1]=40 //fmt.Println(b) //fmt.Println(a) ////原数组的修改会影响切片 ////切片的修改也会影响底层数组 //a[1]=20 //fmt.Println(b) //更多用法,没有步长 //var a [8]int=[8]int{1,2,3,4,5,6,7,8} //b:=a[:4] //fmt.Println(b) //第二种方式，直接定义 //切片空值是？nil类型 //var a []int //if a==nil{ // fmt.Println("我是空的") //} //a[0]=10 //fmt.Println(a) //定义并初始化,第一个参数是类型，第二个参数是切片的长度，第三个参数是底层数组长度,也就是切片的容量 //var a []int=make([]int,3) //fmt.Println(a) //切片的长度和容量(len cap:容量) //切片的长度就是它所包含的元素个数。 //切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。 //var a [8]int=[8]int{1,2,3,4,5,6,7,8} //var b []int=a[2:6] //fmt.Println(len(b)) //fmt.Println(cap(b)) //var a []int=make([]int,3,4) //fmt.Println(a) //fmt.Println(len(a)) //fmt.Println(cap(a)) //切片追加值(即给切片赋值) //var a [8]int=[8]int{1,2,3,4,5,6,7,8} //var b []int=a[2:6] //fmt.Println(len(b)) //4 //fmt.Println(cap(b)) //6 ////内置函数append，append函数的返回值也为切片 //b=append(b,555) //b=append(b,666) //追加两个值之后，容量为6，长度为6 //底层数组a的相应位置数据也被修改了 //fmt.Println(b) //fmt.Println(len(b)) //fmt.Println(cap(b)) //b[0]=999 //fmt.Println(a) //a[2]变为999 //容量满了再继续追加 //b=append(b,777) //fmt.Println(b) //长度为7 //fmt.Println(len(b)) //切片容量翻倍为12 //fmt.Println(cap(b)) //当切片超出底层数组长度时，再进行追加会重新创建一个数组，修改切片中的值不会影响原数组中的值 //b[0]=999 //fmt.Println(b) //fmt.Println(a) //var b =make([]int,3,4) //fmt.Println(b) //[0,0,0] //b=append(b,4) //fmt.Println(b) //[0,0,0,4] //fmt.Println(len(b)) //4 //fmt.Println(cap(b)) //4 //b=append(b,5) //fmt.Println(len(b)) //5 //fmt.Println(cap(b)) //8 //切片的修改 //var b =make([]int,3,4) //b[0]=999 //fmt.Println(b) //var b =make([]int,4,4) //fmt.Println(len(b)) //fmt.Println(cap(b)) //切片的函数传递 //var b =make([]int,3,4) //test(b) //在函数中修改之后原b切片的值也会改变，即切片是引用传递 //fmt.Println(b) //切片的数据结构表示 //type slice struct { // Length int // Capacity int // ZerothElement *byte //} //多维切片 //var a [][]string=make([][]string,2,3) //fmt.Println(a[0]) //[]为空切片，只初始化了外层切片 //a[0]=make([]string,2,3) //为内层切片初始化 //if a[0]==nil{ // fmt.Println("xxxx") //} //切片初始化的方法 //var a []int=[]int{1,2,3} //fmt.Println(a) //fmt.Println(len(a)) //fmt.Println(cap(a)) //多维切片初始化 //var a [][]string=[][]string{{"1","2"},{"3","4"}} //fmt.Println(a) //fmt.Println(len(a)) //fmt.Println(cap(a)) //a[0][1]="999" //fmt.Println(a) //a[1][0]="999" //var a []int=[]int{1,2} //fmt.Println(a) //a=append(a,3) //fmt.Println(len(a)) //fmt.Println(cap(a)) //a[2]=99 //a[3]=888 //fmt.Println(a) //copy函数 var a =make([]int,3,10000) //底层数组很大，耗费内存 a[1]=99 a[2]=888 fmt.Println(a) //var b =make([]int,4,4) var b =make([]int,2,4) fmt.Println(b) //将a copy 到另一个切片上去 copy(b,a) fmt.Println(b) } func test(b []int) { b[0]=999 fmt.Println(b) }
可变长参数：
package main //可变长参数 import "fmt" //可变长参数 func main() { //var a =[]int{1,2,4,} //test1(1,2,3,4) //相当于打散了 //test1(a...) //veggies := []string{"potatoes", "tomatoes", "brinjal"} //fruits := []string{"oranges", "apples"} //food := append(veggies, fruits...) //fmt.Println("food:",food) //循环多维切片 pls := [][]string { {"C", "C++"}, {"JavaScript"}, {"Go", "Rust"}, } fmt.Println(pls) for _,v:=range pls { for _,v1:=range v{ fmt.Println(v1) } } } func test1(a ...int) { fmt.Println(a) fmt.Printf("%T",a) }
二、map
map:在Go中将键(key)值(value)关联起来的内置类型，通过相应的键来获取相应的值。
map中放函数和用map实现set练习：
package main //回顾 //func main() { //指针数组和数组指针 //数组里面放指针 指向数组的指针 // //a:=10 //b:=20 ////数组里面放指针 //c:=[2]*int{&a,&b} //fmt.Println(c) //指向数组的指针 //a:=[2]int{1,2} //var b *[2]int //b=&a //fmt.Println(b) //} //-map内放函数 //func main() { // var m map[int]func(a int)int=make(map[int]func(a int)int) // m[1]= func(a int) int { // // return a // } // m[2]= func(a int) int { // return a*a // } // m[3]= func(a int) int { // return a*a*a // } // // fmt.Println(m[1](9)) // fmt.Println(m[2](9)) // fmt.Println(m[3](9)) //} //-通过map实现set func main() { //集合 //可以放值，如果重复了，放不进去 //可以获取长度 //判断一个值是否在集合内 //把集合内所有元素打印出来 // //var m map[string]bool=make(map[string]bool) //m["lqz"]=true //m["egon"]=true // //m["lqz"]=true // //fmt.Println(len(m)) ////"aa"是否在集合内 //if m["aa"]{ // fmt.Println("在里面") //}else { // fmt.Println("不再") //} //for k,_:=range m{ // fmt.Println(k) //} }
//maps package main import "fmt" func main() { //maps的定义 //map的key值必须可hash //var a map[键值类型]value值类型 //map的空值是nil类型 //也是引用类型，在函数中修改原来的值也会被修改 //var a map[int]string //fmt.Println(a) //if a==nil{ // fmt.Println("xxxx") //} //map的赋值跟取值 //map的初始化 //var a map[int]string=make(map[int]string) //fmt.Println(a) ////if a==nil{ //// fmt.Println("xxxxx") ////} //a[1]="100" //a[2]="888" //fmt.Println(a) //fmt.Println(a[1]) ////取一个不存在的key值会？返回value值的空值的默认值(int为0，string为“”) ////fmt.Println(a[9]) //var b map[int]int=make(map[int]int) //b[1]=100 //fmt.Println(b) ////fmt.Println(b[9]) //if v,ok:=a[9];ok{ // fmt.Println("=-====",v) //}else { // fmt.Println("该值不存在") //} //v,ok:=a[1] //fmt.Println(v) //fmt.Println(ok) //定义和初始化的第二种方式 //var a =map[int]string{1:"10",2:"100"} ////a[1] //fmt.Println(a[1]) //字典删除元素，内置函数 //var a =map[int]string{1:"10",2:"100"} ////delete(a,2) //delete(a,3) //fmt.Println(a) //map长度 //var a =map[int]string{1:"10",2:"100"} //delete(a,1) //a[10]="999" //fmt.Println(len(a)) //Map 是引用类型 //var a =map[int]string{1:"10",2:"100"} //test4(a) //fmt.Println(a) //Map 的相等性 //map1 := map[string]int{ // "one": 1, // "two": 2, //} // //map2 := map1 //if map1 == map2 { //报错 //} //map循环出所有元素 ////map是无序的 //for k,v:=range a{ // fmt.Println(k) // fmt.Println(v) //} //补充：切片删除元素 //var a =[]int{1,2,3,4,5,6} //a=append(a[0:2],a[3:]...) //fmt.Println(a) } func test4(a map[int]string) { a[1]="888" fmt.Println(a) } //把map做成有序作业
三、字符串
字符串：
package main import ( "fmt" "unicode/utf8" ) func main() { //name := "Hello World刘清政" //name:="刘" //字符串长度，len统计字节数 //在go中string类型都是utf-8编码 //fmt.Println(len(name)) //fmt.Println(utf8.RuneCountInString(name)) //unicode是一个字符编码对照表 //循环 //字符串是个只读切片 //name := "name刘" //循环的是字节 //for i:=0;i<len(name);i++{ // fmt.Println(string(name[i])) // fmt.Printf("%T",name[i]) // fmt.Println() //} //循环的是字符 //for _,v:=range name{ // fmt.Println(string(v)) // fmt.Printf("%T",v) // fmt.Println() //} //name := "name刘" //name[0]=99 //fmt.Println(name[0]) //fmt.Println(string(name[0])) byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9} str := string(byteSlice) a:=len(str) b:=utf8.RuneCountInString(str) fmt.Println(b) fmt.Println(a) fmt.Println(str) }
四、指针
指针：是一种存储变量内存地址的变量。
//指针 package main import "fmt" func main() { //&取地址符号 //* 放在类型旁边，表示指向这个类型的指针 //* 放在变量旁边，表示解引用（反解） //a:=10 //b就是一个指针 指向int类型的指针 //b:=&a //d:="sss" //var c *string=&d //var b *int =&a //fmt.Println(b) //fmt.Println(*b) //c:=&b //var c **int=&b //fmt.Println(*(*c)) //指针的零值（Zero Value）,nil类型 //var a *int //fmt.Println(a) //向函数传递指针参数 //a:=10 ////b:=&a ////test6(b) ////fmt.Println(a) //test7(a) //fmt.Println(a) //func test6(b *int) { // //*b 就是 a a++ // *b++ //原来a的值也会被修改 // fmt.Println(*b) //} //func test7(b int) { // b++ //原来a的值不会改变 // fmt.Println(b) //不要向函数传递数组的指针，而应该使用切片 //var a [100]int ////test9(&a) ////fmt.Println(a) //test10(a[:]) //fmt.Println(a) //Go 不支持指针运算 } // 若向函数传递指针则数组指针的长度写死了，受众范围小 func test9(a *[4]int) { (*a)[0]=999 //底层数组也会受到影响 fmt.Println(a) } func test10(a []int) { //使用切片同样可以修改底层数组 a[0]=999 fmt.Println(a) } //}
五、结构体
package main //结构体：是一系列属性的集合 //定义一个人结构体 //type关键字 结构体名字 struct{} //type Person struct { // name string // sex ,age int // //} //匿名字段表示字段没有名字 //type Person struct { // string // int //} //嵌套结构体 //type Person struct { // name string // sex ,age int // hobby Hobby // //} //type Hobby struct { // id int // name string //} //结构体嵌套+匿名字段 type Person struct { name string sex ,age int Hobby } type Hobby struct { id int //hobbyname string name string } func main() { //person :=Person{} //定义没有初始化 //结构体是值类型 //var person Person //var person Person=Person{name:"lqz"} //var person Person=Person{"lqz",1,19} ////person.name="lqz" //fmt.Println(person.name) //匿名结构体 //age:=10 //name:="lqz" // //a:=struct { // name string // age int //}{"lqz",19} //fmt.Printf(a.name) //结构体的零值 //结构体指针 //p:=Person{name:"lqz"} ////pPoint:=&p //var pPoint *Person=&p ////fmt.Println(pPoint) ////fmt.Println((*pPoint).name) //可以直接指针.变量名来获取 //fmt.Println(pPoint.name) //匿名字段(用作变量提升) //p:=Person{"lqz",19} //用类型名来代替变量名 //p:=Person{string:"lqz",int:19} //fmt.Println(p.string) //嵌套结构体 //p:=Person{name:"lqz",hobby:Hobby{10,"篮球"}} //p:=Person{name:"lqz",hobby:Hobby{id:10,name:"篮球"}} //p.hobby.id=101 // //fmt.Println(p.hobby.name) //结构体嵌套加匿名字段 //p:=Person{name:"lqz",Hobby:Hobby{10,"篮球"}} ////取p中的hobbyname //fmt.Println(p.Hobby.hobbyname) //fmt.Println(p.hobbyname) //变量提升过程中如果有重名的，就不提升了 //p:=Person{name:"lqz",Hobby:Hobby{10,"篮球"}} //fmt.Println(p.Hobby.name) //fmt.Println(p.name) //结构体相等性 }
六、方法
方法：方法其实就是一个函数，在func关键字和方法名之间加入了一个特殊的接收器类型，接收器可以是结构体类型，或者非结构体类型，接收器是可以在方法的内部访问的
package main import "fmt" //方法 其实就是一个函数 type Person struct { name string age int sex int } //语法 //func (a Person) getName() { // //} //方法给对象用 //给Person结构体加一个打印名字的方法 func (a Person)printName() { fmt.Println(a.name) } //func (a Person)changeName(name string) { // a.name=name // fmt.Println(a) //} func (a *Person)changeName(name string) { a.name=name fmt.Println(a) } //func printName(a Person) { // fmt.Println(a.name) //} //func printName(a *Person) { // fmt.Println(a.name) //} func main() { //var p *Person=&Person{name:"lqz"} //这种也可以，go给你处理了 //var p Person=Person{name:"lqz"} //p.changeName("egon") 值类型的接收器，不会影响原p的值 //fmt.Println(p) //p.printName() //为什么我们已经有函数了还需要方法呢 //执行函数 //printName(p) //printName(&p) //指针接收器与值接收器 //func (值)changeName(name string)：在内部修改值，不会影响外部的值 //func (指针)changeName(name string)：在内部修改值，会影响外部的值 //那么什么时候使用指针接收器，什么时候使用值接收器 //想修改原值，就用指针接收器 //匿名字段的方法 }
非结构体上的方法：
package main import "fmt" //在非结构体上的方法 //重命名 type MyInt int func (i *MyInt)add() { (*i)++ fmt.Println(*i) } func main() { var a MyInt=10 a.add() fmt.Println(a) }
在方法中使用值接收器 与 在函数中使用值参数
在方法中使用指针接收器 与 在函数中使用指针参数
package main import "fmt" //在方法中使用值接收器 与 在函数中使用值参数 //在方法中使用指针接收器 与 在函数中使用指针参数 type Person2 struct { name string age int sex int } //方法中使用值接收器 func (a Person2)printName() { fmt.Println(a.name) } //方法中使用指针接收器 func (a *Person2)printName2() { fmt.Println(a.name) } //函数中使用值参数 func printName(a Person2) { fmt.Println(a.name) } //在函数中使用指针参数 func printName2(a *Person2) { fmt.Println(a.name) } func main() { //p:=&Person2{name:"lqz"} //调用值接收器 //p.printName() //调用指针接收器 //p.printName2() //调用值函数 //printName(p) //调用指针函数 //printName2(&p) //方法中： //不管是指针接收器还是值接收器，都可以使用值来调用 //不管是指针接收器还是值接收器，都可以使用指针来调用 //函数中： //是什么参数，就得传什么参数 }
七、接口
接口：在面向对象中，接口一般定义一个对象的行为，接口只是制定了对象应该做什么，至于如何实现这个行为，则由对象本身去决定。