面向对象

面向过程

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

import "fmt"

func compare(a, b int) bool {
	return a < b
}
func main() {
	a, b := 1, 2
	fmt.Println(compare(a, b))
}

// 以上代码运行结果：
true

类声明

面向对象

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
40
41
42
43
44
package main

import "fmt"

// 定义一个 Book 结构体 （相当于其他语言中的声明一个类）
type Book struct {
	name string
}

// 给 Book 结构体声明一个值传递方法，（相当于类声明方法）
func (book Book) changName1(name string) string {
	book.name = name
	return book.name
}

// 给 Book 结构体声明一个指针传递方法，
func (book *Book) changeName2(name string) string {
	book.name = name
	return book.name
}
func main() {
	// 声明一个 Book 类型的变量 b
	b := Book{"时间简史"}
    
	fmt.Println(b.name)
	// 调用值传递方法 changName1
	b.changName1("两只老虎爱跳舞")
	fmt.Println(b.name)

	fmt.Println("====================")
    
	fmt.Println(b.name)
	// 调用指针传递方法 changName2
	b.changeName2("两只老虎爱跳舞")
	fmt.Println(b.name)

}

// 以上代码运行结果：
时间简史
时间简史
====================
时间简史
两只老虎爱跳舞

继承

确切的说 golang 中叫做组合（composition）

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
40
41
42
43
44
45
46
47
48
49
50
51
package main

import (
	"fmt"
)

// 类声明
type Persons struct {
	Name string
	Age  int
}

// 获取Name
func (p *Persons) getName() {
	fmt.Println("Name is ", p.Name)
}

type Student struct {
	// Student 属性中声明了 Persons，表示组合了Persons 的属性和方法(属性和方法都会被继承)
	Persons
	Name   string
	school string
}

func main() {

	// 先初始化为空再赋值
	s1 := &Student{}
	// 当访问Name的时候默认为ProsePoem的 Name，如果需要访问Persons 的 Name 属性可以使用 s1.Persons.Name 来访问方法同理。
	s1.Name = "john"
	s1.Persons.Name = "Persons Name"
	s1.Persons.Age = 24
	s1.school = "QH"
	fmt.Println("s1 = ", s1)

	// 直接赋值
	s2 := &Student{
		Persons: Persons{
			Name: "Persons Name",
			Age:  24,
		},
		Name:   "john",
		school: "QH",
	}
	fmt.Println("s2 = ", s2)
}


// 以上代码运行结果：
s1 =  &{{Persons Name 24} john QH}
s2 =  &{{Persons Name 24} john QH}