1 struct</h2>
在Golang中没有对象,但是有面向对象的思想,有继承,多态,封装的思想。
但是缺少了class,而取而代之的是struct(结构体)
下面的是几种结构体的初始化方法4种方法
<pre><code>package main
import "fmt"
//结构体 - 对象
type cat struct{
name string
age int
sex string
}
func main(){
var cat1 cat
cat1.name = "小白"
cat1.age = 12
cat1.sex = "男"
fmt.Println(cat1)
}
</code></pre>
<pre><code>type Person struct{
Name string
Age int
}
func main(){
//2.
P := Person{}
P.Name = "tom"
P.Age = 15
fmt.Println(P)
p2:=Person{"marry",20}
fmt.Println(p2)
//3
var p3 *Person = new(Person)
(*p3).Name = "city"
(*p3).Age = 16
p3.Name = "kinh"
fmt.Println(p3)
fmt.Println(*p3)
//4.
var p4 *Person = &Person{}
(*p4).Name = "scott"
(*p4).Age = 29
p4.Age = 24
fmt.Println(p4)
fmt.Println(*p4)
}
</code></pre>
强调 1
需要强调的是结构体的地址是连续性分布的,所以很多编程高手不需要编程得到地址，反而可以直接通过地址连续这一特性。获得下一结构体的地址。
<pre><code>type Point struct{
x int
y int
}
type Rect struct{
leftUp, rightDown Point
}
func main(){
r1 := Rect{Point{1,2},Point{4,5}}
fmt.Println(&r1.leftUp.x,&r1.leftUp.y)
fmt.Println(&r1.rightDown.x,&r1.rightDown.y)
}
</code></pre>
结果
0xc042008340 0xc042008348
0xc042008350 0xc042008358
强调 2
结构体如果要相互转换赋值的话,必须是两个机构体的字段名相同,且类型相同,数量一样
<pre><code>package main
import "fmt"
type A struct {
num int
}
type B struct{
num int
}
func main(){
var a A
var b B
//强行转换
//必须字段和类型都一样
//字段名
//还有个数也要一样
a = A(b)
fmt.Println(a,b)
}
</code></pre>
结果
{0} {0}
强调 3
如果结构体转换名称了也应该强转,原因是转换了名称Golang就相当于不同的结构体了
<pre><code>type student struct{
name string
age int
}
type stu student//换个名称
func main(){
var student1 student
var student2 stu
//就算改了个名字也会认为是不同的类型
//也需要强转
student1 = student(student2)
fmt.Println(student1,student2)
}
</code></pre>
强调 4
tag的概念:
相当于把一个属性转换了一个名字,比如有些程序员方便用小写的名字,然后在Golang中
小写代表着private,所以可以用tag来转换
<pre><code>package main
import "fmt"
import "encoding/json"
type Master struct{
Name string `json:"name"`
Age int `json:"age"`
Skill string `json:"skill"`
}
func main(){
m1 := Master{"孙悟空",14,"火焰"}
jsonstr, err := json.Marshal(m1)
if err != nil{
fmt.Println("No")
}
fmt.Println(jsonstr)
fmt.Println(string(jsonstr))
}
</code></pre>
结果
[123 34 110 97 109 101 34 58 34 229 173 153 230 130 159 231 169 186 34 44 34 97 103 101 34 58 49 52 44 34 115 107 105 108 108 34 58 34 231 129 171 231 132 176 34 125]
{“name”:“孙悟空”,“age”:14,“skill”:“火焰”}
<h2>2 map</h2>
map在Golang中也有,也是以键值对的形式。
初始化map
<pre><code>package main
import "fmt"
func main(){
var a map[string]string
//必须要先make分配空间
//Golang种的map为无序的key排序
//key一样为替换
a = make(map[string]string,10)
a["1"] = "同学"
fmt.Println(a)
}
</code></pre>
<pre><code>func main(){
var a map[string]string
//1,
a = make(map[string]string,10)
a["1"] = "tengxun"
a["2"] = "shanghai"
fmt.Println(a)
//2
citis := make(map[string]string)
citis["1"] = "beijing"
citis["2"] = "shanghai"
fmt.Println(citis)
//3
var heros map[string]string = map[string]string{
"1":"wuyong",
"2":"lujingyi",
}
fmt.Println(heros)
hero := map[string]string{
"1":"ateman",
"2":"dahai",
}
fmt.Println(hero)
}
</code></pre>
结果
map[2:shanghai 1:tengxun]
map[1:beijing 2:shanghai]
map[1:wuyong 2:lujingyi]
map[1:ateman 2:dahai]
map中套map
<pre><code>func main(){
//map的添加的问题:
student := make(map[string]map[string]string)
student["1"] = make(map[string]string,2)
student["1"]["name"] = "tom"
student["1"]["sex"] = "男"
student["1"]["address"] = "123"
student["2"] = make(map[string]string)
student["2"]["name"] = "jerry"
student["2"]["sex"] = "nv"
fmt.Println(student["1"],student["2"])
}
</code></pre>
结果
map[name:tom sex:男 address:123] map[name:jerry sex:nv]
map的增删改查操作
<pre><code>func main(){
//map的增删改查的操作
var heros map[string]string
heros = make(map[string]string)
heros["1"] = "1"
heros["2"] = "2"
fmt.Println(heros)
heros["3"] = "3"
fmt.Println(heros)
//删除
//有则删除无则不会报错
delete(heros,"1")
fmt.Println(heros)
//查找
//ok为布尔型,有则为true无则为false
//val为value
val, ok := heros["1"]
if ok {
fmt.Println(val)
}else{
fmt.Println("No")
}
//如果想把heros里面的东西全部清空则直接初始化即可
heros = make(map[string]string)
fmt.Println(heros)
}
</code></pre>
结果
map[1:1 2:2]
map[1:1 2:2 3:3]
map[2:2 3:3]
No
map[]
map的遍历
遍历通常单位是对。
<pre><code>func main(){
//map的遍历:只可以使用for-range的方式
cites := make(map[int]int)
cites[1] = 1
cites[2] = 3
cites[3] = 5
//遍历:
for k,v := range cites{
fmt.Println(k,v)
}
//len内置函数:单位为对
fmt.Println(len(cites))
//3对
}
</code></pre>
结果
3
map的可序化
在Golang中map的排序不是按照key的值来排序的。一般是无序的
下面的方法可以按照key的顺序排序
<pre><code> //1.先将map的key放入到切片种
//2.对切片排序
//3.遍历切片,按照key来输出value
</code></pre>
<pre><code>func main(){
//按照key顺序排序
//1.先将map的key放入到切片种
//2.对切片排序
//3.遍历切片,按照key来输出value
map1 := make(map[int]int,10)
map1[1] = 10
map1[2] = 20
map1[4] = 20
var keys []int
for k,_ := range map1{
keys = append(keys,k)
}
sort.Ints(keys)
fmt.Println(keys)
for _,k := range keys{
fmt.Println(map1[k])
}
}
</code></pre>
<h2>