1
// 永远不要高估自己!
2

3
// 递归:函数自己调用自己!
4
// 递归适合处理那种问题相同\问题的规模越来越小的场景
5
// 递归一定要有一个明确的退出条件
6

7
// 3! = 3*2*1     = 3*2!
8
// 4! = 4*3*2*1   = 4*3!
9
// 5! = 5*4*3*2*1 = 5*4!
10

11
// 计算n的阶乘
12
func f(n uint64) uint64 {
13
  if n <= 1 {
14
    return 1
15
  }
16
  return n * f(n-1)
17
}
18

19
// 上台阶的面试题
20
// n个台阶，一次可以走1步，也可以走2步，有多少种走法。
21
func taijie(n uint64) uint64 {
22
  if n == 1 {
23
    // 如果只有一个台阶就一种走法
24
    return 1
25
  }
26
  if n == 2 {
27
    return 2
28
  }
29
  return taijie(n-1) + taijie(n-2)
30
}
31

32
func main() {
33
  // ret := f(7)
34
  // fmt.Println(ret)
35
  ret := taijie(4)
36
  fmt.Println(ret)
37
}

1
// 自定义类型和类型别名
2
// type后面跟的是类型
3
type myInt int     // 自定义类型
4
type yourInt = int // 类型别名
5
func main() {
6
  var n myInt
7
  n = 100
8
  fmt.Println(n)
9
  fmt.Printf("%T  %d\n", n, n)
10

11
  var m yourInt
12
  m = 100
13
  fmt.Println(m)
14
  fmt.Printf("%T\n", m)
15

16
  var c rune
17
  c = '中'
18
  fmt.Println(c)
19
  fmt.Printf("%T\n", c)
20
}

1
// 结构体
2
type person struct {
3
  name   string
4
  age    int
5
  gender string
6
  hobby  []string
7
}
8

9
func main() {
10
  // 声明一个person类型的变量p
11
  var p person
12
  // 通过字段赋值
13
  p.name = "周林"
14
  p.age = 9000
15
  p.gender = "男"
16
  p.hobby = []string{"篮球", "足球", "双色球"}
17
  fmt.Println(p)
18
  // 访问变量p的字段
19
  fmt.Printf("%T\n", p)
20
  fmt.Println(p.name)
21
  var p2 person
22
  p2.name = "理想"
23
  p2.age = 18
24
  fmt.Printf("type:%T value:%v\n", p2, p2)
25

26
  // 匿名结构体:多用于临时场景
27
  var s struct {
28
    x string
29
    y int
30
  }
31
  s.x = "嘿嘿嘿"
32
  s.y = 100
33
  fmt.Printf("type:%T value:%v\n", s, s)
34
}

1
// 结构体是值类型
2
type person struct {
3
  name, gender string
4
}
5

6
// go语言中函数传参数永远传的是拷贝
7
func f(x person) {
8
  x.gender = "女" // 修改的是副本的gender
9
}
10

11
func f2(x *person) {
12
  // (*x).gender = "女" // 根据内存地址找到那个原变量,修改的就是原来的变量
13
  x.gender = "女" // 语法糖,自动根据指针找对应的变量
14
}
15

16
func main() {
17
  var p person
18
  p.name = "周林"
19
  p.gender = "男"
20
  f(p)
21
  fmt.Println(p.gender) // 男
22
  f2(&p)                // ox1241ac3
23
  fmt.Println(p.gender) // 女
24
  // 结构体指针1
25
  var p2 = new(person)
26
  (*p2).name = "理想"
27
  p2.gender = "保密"
28

29
  fmt.Printf("%T\n", p2)
30
  fmt.Printf("%p\n", p2)  // p2保存的值就是一个内存地址
31
  fmt.Printf("%p\n", &p2) // 求b2的内存地址
32
  // 2. 结构体指针2
33
  // 2.1 key-value初始化
34
  var p3 = &person{
35
    name: "元帅",
36
  }
37
  fmt.Printf("%#v\n", p3)
38
  // 2.2 使用值列表的形式初始化, 值的顺序要和结构体定义时字段的顺序一致
39
  p4 := &person{
40
    "小王子",
41
    "男",
42
  }
43
  fmt.Printf("%#v\n", p4)
44
}

1
//
2
func main() {
3
  var a int
4
  a = 100
5
  b := &a
6
  fmt.Printf("type a:%T type b:%T\n", a, b)
7
  // 将a的十六进制内存地址打印出来
8
  fmt.Printf("%p\n", &a)
9
  fmt.Printf("%p\n", b) // b的值
10
  fmt.Printf("%v\n", b)
11
  fmt.Printf("%p\n", &b) // b的内存地址
12
}

1
// 结构体占用一块连续的内存空间
2

3
type x struct {
4
  a int8 // 8bit => 1byte
5
  b int8
6
  c int8
7
}
8
func main() {
9
  m := x{
10
    a: int8(10),
11
    b: int8(20),
12
    c: int8(30),
13
  }
14
  fmt.Printf("%p\n", &(m.a))
15
  fmt.Printf("%p\n", &(m.b))
16
  fmt.Printf("%p\n", &(m.c))
17
}

1
// 构造函数
2
type person struct {
3
  name string
4
  age  int
5
}
6

7
type dog struct {
8
  name string
9
}
10

11
// 构造函数:约定成俗用new开头
12
// 返回的是结构体还是结构体指针
13
// 当结构体比较大的时候尽量使用结构体指针,减少程序的内存开销
14
func newPerson(name string, age int) *person {
15
  return &person{
16
    name: name,
17
    age:  age,
18
  }
19
}
20

21
func newDog(name string) dog {
22
  return dog{
23
    name: name,
24
  }
25
}
26

27
func main() {
28
  p1 := newPerson("元帅", 18)
29
  p2 := newPerson("周林", 9000)
30
  fmt.Println(p1, p2)
31
  d1 := newDog("周林")
32
  fmt.Println(d1)
33
}

1
// 方法
2

3
// 标识符:变量名 函数名 类型名 方法名
4
// Go语言中如果标识符首字母是大写的,就表示对外部包可见(暴露的,公有的).
5

6
// dog 这是一个狗的结构体
7
type dog struct {
8
  name string
9
}
10

11
type person struct {
12
  name string
13
  age  int
14
}
15

16
func newPerson(name string, age int) *person {
17
  return &person{
18
    name: name,
19
    age:  age,
20
  }
21
}
22

23
// 构造函数
24
func newDog(name string) dog {
25
  return dog{
26
    name: name,
27
  }
28
}
29

30
// 方法是作用于特定类型的函数
31
// 接受者表示的是调用该方法的具体类型变量,多用类型名首字母小写表示
32
func (d dog) wang() {
33
  fmt.Printf("%s:汪汪汪~", d.name)
34
}
35

36
// 使用值接收者:传拷贝进去
37
// func (p person) guonian() {
38
//   p.age++
39
// }
40

41
// 指针接收者:传内存地址进去
42
func (p *person) zhenguonian() {
43
  p.age++
44
}
45

46
func (p *person) dream() {
47
  fmt.Println("不上班也能挣钱!")
48
}
49

50
func main() {
51
  // d1 := newDog("zhoulin")
52
  // d1.wang()
53
  p1 := newPerson("元帅", 18)
54
  // p1.wang()
55
  fmt.Println(p1.age) // 18
56
  // p1.guonian()
57
  fmt.Println(p1.age) // 18
58
  p1.zhenguonian()
59
  fmt.Println(p1.age) // ?
60
  p1.dream()
61
}

1
// 给自定义类型加方法
2
// 不能给别的包里面的类型添加方法,只能给自己包里的类型添加方法
3
type myInt int
4
func (m myInt) hello() {
5
  fmt.Println("我是一个int")
6
}
7
func main() {
8
  m := myInt(100)
9
  m.hello()
10
}

1
// 结构体遇到的问题
2

3
// 1. myInt(100)是个啥?
4
type myInt int
5

6
func (m myInt) hello() {
7
  fmt.Println("我是一个int")
8
}
9

10
type person struct {
11
  name string
12
  age  int
13
}
14

15
func main() {
16
  // 声明一个int32类型的变量x,它的值是10
17
  // 方法1:
18
  // var x int32
19
  // x = 10
20
  // 方法2:
21
  // var x int32 = 10
22
  // 方法3:
23
  // var x = int32(10)
24
  // 方法4:
25
  // x := int32(10)
26
  // fmt.Println(x)
27

28
  // 声明一个myInt类型的变量m,它的值是100
29
  // 方法1:
30
  // var m myInt
31
  // m = 100
32
  // 方法2:
33
  // var m myInt = 100
34
  // 方法3:
35
  // var m = myInt(100)
36
  // 方法4
37
  // m := myInt(100) // 强制类型转换
38
  // fmt.Println(m)
39
  // m := myInt(100)
40
  // m.hello()
41

42
  // 问题2:结构体初始化
43

44
  // 方法1:
45
var p person // 声明一个person类型的变量p
46
p.name = "元帅"
47
p.age = 18
48
fmt.Println(p)
49
  var p1 person
50
  p1.name = "周林"
51
  p1.age = 9000
52
  fmt.Println(p1)
53
  // 方法2:
54
  s1 := []int{1, 2, 3, 4}
55
  m1 := map[string]int{
56
    "stu1": 100,
57
    "stu2": 99,
58
    "stu3": 0,
59
  }
60
  fmt.Println(s1, m1)
61
// 键值对初始化
62
var p2 = person{
63
  name: "冠华",
64
  age:  15,
65
}
66
fmt.Println(p2)
67
// 值列表初始化
68
var p3 = person{
69
  "理想",
70
  100,
71
}
72
fmt.Println(p3)
73
}
74

75
// 问题3:为什么要有构造函数
76
func newPerson(name string, age int) person {
77
  // 别人调用我,我能给她一个person类型的变量
78
  return person{
79
    name: name,
80
    age:  age,
81
  }
82
}
83

84
// func newPerson(name string, age int) *person {
85
//   // 别人调用我,我能给她一个person类型的变量
86
//   return &person{
87
//     name: name,
88
//     age:  age,
89
//   }
90
// }

1
/*
2
  函数版学生管理系统
3
  写一个系统能够查看\新增学生\删除学生
4
*/
5
var (
6
  allStudnet map[int64]*student // 变量声明
7
)
8
type student struct {
9
  id   int64
10
  name string
11
}
12
// newStudent 是student类型的构造函数
13
func newStudent(id int64, name string) *student {
14
  return &student{
15
    id:   id,
16
    name: name,
17
  }
18
}
19
func showAllStudent() {
20
  // 把所有的学生都打印出来
21
  for k, v := range allStudnet {
22
    fmt.Printf("学号:%d 姓名:%s\n", k, v.name)
23
  }
24
}
25

26
func addStudent() {
27
  // 向allStudent中添加一个新的学生
28
  // 1. 创建一个新学生
29
  // 1.1 获取用户输入
30
  var (
31
    id   int64
32
    name string
33
  )
34
  fmt.Print("请输入学生学号:")
35
  fmt.Scanln(&id)
36
  fmt.Print("请输入学生姓名:")
37
  fmt.Scanln(&name)
38
  // 1.2 造学生(调用student的构造函数)
39
  newStu := newStudent(id, name)
40
  // 2. 追加到allStudent这个map中
41
  allStudnet[id] = newStu
42
}
43

44
func deleteStudnet() {
45
  // 1. 请用户输入要删除的学生的序号
46
  var (
47
    deleteID int64
48
  )
49
  fmt.Print("请输入学生学号:")
50
  fmt.Scanln(&deleteID)
51
  // 2. 去allStudent这个map中根据学号删除对应的键值对
52
  delete(allStudnet, deleteID)
53
}
54

55
func main() {
56
  allStudnet = make(map[int64]*student, 48) // 初始化(开辟内存空间)
57
  for {
58
    // 1. 打印菜单
59
    fmt.Println("欢迎光临学生管理系统!")
60
    fmt.Println(`
61
    1. 查看所有学生
62
    2. 新增学生
63
    3. 删除学生
64
    4. 退出
65
  `)
66
    fmt.Print("请输入你要干啥:")
67
    // 2. 等待用户选择要做什么
68
    var choice int
69
    fmt.Scanln(&choice)
70
    fmt.Printf("你选择了%d这个选项!\n", choice)
71
    // 3. 执行对应的函数
72
    switch choice {
73
    case 1:
74
      showAllStudent()
75
    case 2:
76
      addStudent()
77
    case 3:
78
      deleteStudnet()
79
    case 4:
80
      os.Exit(1) // 退出
81
    default:
82
      fmt.Println("滚~")
83
    }
84
  }
85
}

1
// 匿名字段
2
// 字段比较少也比较简单的场景
3
// 不常用!!!
4

5
type person struct {
6
  string
7
  int
8
}
9

10
func main() {
11
  p1 := person{
12
    "周林",
13
    9000,
14
  }
15
  fmt.Println(p1)
16
  fmt.Println(p1.string)
17
  fmt.Println(p1.int)
18
}

1
// 结构体嵌套
2

3
type address struct {
4
  province string
5
  city     string
6
}
7

8
type workPlace struct {
9
  province string
10
  city     string
11
}
12

13
type person struct {
14
  name    string
15
  age     int
16
  address // 匿名嵌套结构体
17
  workPlace
18
  // address:address
19
}
20

21
type company struct {
22
  name string
23
  address
24
}
25

26
func main() {
27
  p1 := person{
28
    name: "周林",
29
    age:  9000,
30
    address: address{
31
      province: "山东",
32
      city:     "威海",
33
    },
34
  }
35
  fmt.Println(p1)
36
  fmt.Println(p1.name, p1.address.city)
37
  // fmt.Println(p1.city) // 先在自己结构体找这个字段,找不到就去匿名嵌套的结构体中查找该字段
38
  fmt.Println(p1.address.city)
39
  fmt.Println(p1.workPlace.city)
40
}

1
// 结构体模拟实现其他语言中的"继承"
2

3
type animal struct {
4
  name string
5
}
6

7
// 给animal实现一个移动的方法
8
func (a animal) move() {
9
  fmt.Printf("%s会动!\n", a.name)
10
}
11

12
// 狗类
13
type dog struct {
14
  feet   uint8
15
  animal // animal拥有的方法,dog此时也有了【www.hlwnjl.com(互联网农家乐)下载免费程序员教程】
16
}
17

18
// 给dog实现一个汪汪汪的方法
19
func (d dog) wang() {
20
  fmt.Printf("%s在叫:汪汪汪~\n", d.name)
21
}
22

23
func main() {
24
  d1 := dog{
25
    animal: animal{name: "周林"},
26
    feet:   4,
27
  }
28
  fmt.Println(d1)
29
  d1.wang()
30
  d1.move() // ?
31
}

1
import (
2
  "encoding/json"
3
  "fmt"
4
)
5
// 结构体与json
6

7
// 1.序列化:   把Go语言中的结构体变量 --> json格式的字符串
8
// 2.反序列化: json格式的字符串   --> Go语言中能够识别的结构体变量
9

10
type person struct {
11
  Name string `json:"name" db:"name" ini:"name"`
12
  Age  int    `json:"age"`
13
}
14

15
func main() {
16
  p1 := person{
17
    Name: "周林",
18
    Age:  9000,
19
  }
20
  // 序列化
21
  b, err := json.Marshal(p1)
22
  if err != nil {
23
    fmt.Printf("marshal failed, err:%v", err)
24
    return
25
  }
26
  fmt.Printf("%v\n", string(b))
27
  // 反序列化
28
  str := `{"name":"理想","age":18}`
29
  var p2 person
30
  json.Unmarshal([]byte(str), &p2) // 传指针是为了能在json.Unmarshal内部修改p2的值
31
  fmt.Printf("%#v\n", p2)
32
}