02 Golang面向对象编程_20240727 课程笔记

视频课程

最近发现越来越多的公司在用Golang了，所以精心整理了一套视频教程给大家，这个是其中的第二部，后续还会有很多。

视频已经录制完成，完整目录截图如下：

课程目录

• 01 结构体的声明.mp4
• 02 使用var根据结构体创建对象.mp4
• 03 使用new根据结构体创建对象.mp4
• 04 使用取地址符根据结构体创建对象.mp4
• 05 结构体的顺序初始化.mp4
• 06 通过工厂函数创建结构体对象.mp4
• 07 将结构体对象转换为JSON字符串.mp4
• 08 将JSON字符串转换为结构体对象.mp4
• 09 结构体的标签.mp4
• 10 结构体的嵌套.mp4
• 11 结构体的方法.mp4
• 12 接口的基本用法.mp4
• 13 通过接口实现多态.mp4
• 14 练习：求三角形的面积.mp4
• 15 面向对象的封装性.mp4
• 16 练习：多态求几何图形的面积.mp4
• 17 接口的组合.mp4
• 18 接口的类型推断.mp4
• 19 通过反射获取变量的类型.mp4
• 20 通过反射判断变量的类型.mp4
• 21 通过反射修改变量的值.mp4

每节课的代码

01 结构体的声明.mp4

package main

// 使用type进行声明
// 使用struct说明这是一个结构体，类似于Java中的class声明一个类
type User struct {
	name string // 小写的说明是内部使用，类似于Java的private
	Age  int    // 大小的说明是外部使用，类似于Java的public
}

1
2
3
4
5
6
7
8
9

02 使用var根据结构体创建对象.mp4

package main

import "fmt"

// 使用type进行声明
// 使用struct说明这是一个结构体，类似于Java中的class声明一个类
type User struct {
	name string // 小写的说明是内部使用，类似于Java的private
	Age  int    // 大小的说明是外部使用，类似于Java的public
}

func main() {
	var u User
	fmt.Println(u)

	u.name = "张三"
	u.Age = 23
	fmt.Println(u)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

03 使用new根据结构体创建对象.mp4

package main

import "fmt"

// 使用type进行声明
// 使用struct说明这是一个结构体，类似于Java中的class声明一个类
type User struct {
	name string // 小写的说明是内部使用，类似于Java的private
	Age  int    // 大小的说明是外部使用，类似于Java的public
}

func main() {
	var u = new(User)
	fmt.Println(u)

	u.name = "张三"
	u.Age = 23
	fmt.Println(u)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

04 使用取地址符根据结构体创建对象.mp4

package main

import "fmt"

// 使用type进行声明
// 使用struct说明这是一个结构体，类似于Java中的class声明一个类
type User struct {
	name string // 小写的说明是内部使用，类似于Java的private
	Age  int    // 大小的说明是外部使用，类似于Java的public
}

func main() {
	var u = &User{
		name: "",
		Age:  0,
	}
	fmt.Println(u)

	u.name = "张三"
	u.Age = 23
	fmt.Println(u)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

05 结构体的顺序初始化.mp4

package main

import "fmt"

// 使用type进行声明
// 使用struct说明这是一个结构体，类似于Java中的class声明一个类
type User struct {
	name string // 小写的说明是内部使用，类似于Java的private
	Age  int    // 大小的说明是外部使用，类似于Java的public
}

func main() {
	var u = User{"张三", 33}
	fmt.Println(u)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

06 通过工厂函数创建结构体对象.mp4

package main

import "fmt"

// 使用type进行声明
// 使用struct说明这是一个结构体，类似于Java中的class声明一个类
type User struct {
	name string // 小写的说明是内部使用，类似于Java的private
	Age  int    // 大小的说明是外部使用，类似于Java的public
}

func NewUser(name string, age int) *User {
	return &User{name, age}
}

func main() {
	var u = NewUser("张三", 33)
	fmt.Println(u)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

07 将结构体对象转换为JSON字符串.mp4

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	name string
	Age  int
}

func main() {
	var u = User{"张三", 33}
	data, err := json.Marshal(u)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(data))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

08 将JSON字符串转换为结构体对象.mp4

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	name string
	Age  int
}

func main() {
	var s = `{"Age":33}`

	var u User
	err := json.Unmarshal([]byte(s), &u)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(u)
	fmt.Println(u.name, u.Age)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

09 结构体的标签.mp4

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	var u = User{"张三", 33}
	data, err := json.Marshal(u)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(data))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

10 结构体的嵌套.mp4

package main

import (
	"encoding/json"
	"fmt"
)

type Address struct {
	Province string `json:"province"`
	City     string `json:"city"`
}

type User struct {
	Name     string  `json:"name"`
	Age      int     `json:"age"`
	UAddress Address `json:"address"`
}

func main() {
	var u = User{"张三", 33, Address{"四川", "成都"}}
	data, err := json.Marshal(u)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(data))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

11 结构体的方法.mp4

package main

import (
	"fmt"
)

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}
type UserManager struct {
	Users []User `json:"users"`
}

func NewUserManager() *UserManager {
	return &UserManager{
		Users: make([]User, 0),
	}
}

func (um *UserManager) AddUser(u User) {
	um.Users = append(um.Users, u)
}

func main() {
	um := NewUserManager()
	um.AddUser(User{"张三", 33})

	fmt.Println(um.Users)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

12 接口的基本用法.mp4

package main

import (
	"fmt"
)

type IAnimal interface {
	Walk()
	Talk()
}

type Cat struct{}

func (cat *Cat) Walk() {
	fmt.Println("蹦蹦跳")
}
func (cat *Cat) Talk() {
	fmt.Println("喵喵喵")
}
func main() {
	var animal IAnimal = new(Cat)
	animal.Walk()
	animal.Talk()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

13 通过接口实现多态.mp4

package main

import (
	"fmt"
)

type IAnimal interface {
	Walk()
	Talk()
}

type Cat struct{}

func (cat *Cat) Walk() {
	fmt.Println("蹦蹦跳")
}
func (cat *Cat) Talk() {
	fmt.Println("喵喵喵")
}

type Dog struct{}

func (cat *Dog) Walk() {
	fmt.Println("四脚着地跑")
}
func (cat *Dog) Talk() {
	fmt.Println("汪汪汪")
}

func main() {
	var animal IAnimal = new(Cat)
	animal.Walk()
	animal.Talk()

	animal = new(Dog)
	animal.Walk()
	animal.Talk()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

14 练习：求三角形的面积.mp4

package main

import "fmt"

type Triangle struct {
	Bottom float32
	Height float32
}

func (t *Triangle) Area() float32 {
	return (t.Height * t.Bottom) / 2
}

func main() {
	t := &Triangle{8, 12}
	fmt.Println(t.Area())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

15 面向对象的封装性.mp4

package user

type User struct {
	name string
}

func (u *User) SetName(name string) {
	u.name = name
}

func (u *User) GetName() string {
	return u.name
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package main

import (
	"fmt"
	"hello_go/c15_user/user"
)

func main() {
	zs := &user.User{}
	zs.SetName("张三")
	fmt.Println(zs.GetName())
}

1
2
3
4
5
6
7
8
9
10
11
12
13

16 练习：多态求几何图形的面积.mp4

package main

import "fmt"

type IShape interface {
	Area() float32
}

type Triangle struct {
	Bottom float32
	Height float32
}

func (t *Triangle) Area() float32 {
	return (t.Height * t.Bottom) / 2
}

type Square struct {
	Width  float32
	Height float32
}

func (s *Square) Area() float32 {
	return s.Height * s.Width
}

func main() {
	var s IShape

	s = &Triangle{8, 12}
	fmt.Println(s.Area())

	s = &Square{8, 12}
	fmt.Println(s.Area())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

17 接口的组合.mp4

package main

type IRead interface {
	Read(path string)
}
type IWrite interface {
	Write(p []byte)
}

// 既拥有IRead相关的接口，也拥有IWrite相关的接口
type IFile interface {
	IRead
	IWrite
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

18 接口的类型推断.mp4

package main

import "fmt"

func main() {
	var a interface{} = 33

	switch a.(type) {
	case int:
		fmt.Println("int")
	case string:
		fmt.Println("string")
	default:
		fmt.Println("unknown")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

19 通过反射获取变量的类型.mp4

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a interface{} = 33

	fmt.Println(reflect.TypeOf(a))
}

1
2
3
4
5
6
7
8
9
10
11
12
13

20 通过反射判断变量的类型.mp4

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a interface{} = 33

	ra := reflect.ValueOf(a)

	fmt.Println("type:", ra.Type())
	fmt.Println(ra.Kind())
	fmt.Println(ra.Kind() == reflect.Int)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

21 通过反射修改变量的值.mp4

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 33
	fmt.Println("修改之前：", a)

	// 如果要修改，一定要传引用
	ra := reflect.ValueOf(&a)

	rae := ra.Elem()
	rae.SetInt(333)

	fmt.Println("修改之后：", a)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

代码截图

总结

本套教程作为Go语言的零基础入门课程，主要讲解了Go语言的一些入门级别的简单基础知识，每节课都附上了完整的源码，以实战为主。

如果您需要完整的源码，打赏20元即可。

人生苦短，我用Python，我是您身边的Python私教~