Golang基础学习笔记

2024-06-18 约 700 字预计阅读 4 分钟

Golang的接口是一种抽象的类型

Go语言中的接口（interface）是一组方法签名的集合，是一种抽象类型。接口定义了方法，但没有实现，而是由具体的类型（struct）实现这些方法，因此接口是一种实现多态的机制。

接口定义

1
2
3
4


type 接口名称er interface{
    func(arg1 类型,arg2 类型2) 返回值
    func(arg3 类型3) 返回值3
}  //最好以er结尾表示  不加func也可以

结构体定义

1
2
3


type 结构体名称 struct{
    Name 类型（string、int、bool等）
}

典型Demo

 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


package main

import (
	"fmt"
)

// Worker 接口定义了一个方法 Work
type Worker interface {
	Work()
}

// programmer 结构体代表一个程序员,定义数据类型
type programmer struct {
	Java   string
	Linux  string
	Python string
}

// Work 实现了 Worker 接口的方法
func (p *programmer) Work() {
	// 输出程序员的类型和使用的编程语言
	fmt.Printf("小李正在学习%s\n", p.Java)
	fmt.Printf("小张正在学习%s\n", p.Linux)
	fmt.Printf("小王正在学习%s\n", p.Python)
}

func main() {
	// 创建一个 programmer 实例，并初始化字段
	myProgrammer := programmer{
		Java:   "Java语言",
		Linux:  "Linux运维",
		Python: "Python语言",
	}
	var Myworker Worker = &myProgrammer // 接口变量赋值也叫实现结构体
	Myworker.Work() //调用接口方法
}

信息

以上代码作为基础进行拓展

一个类型实现多个接口

 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


package main

import (
	"fmt"
	"time"
)

// Worker 接口定义了一个方法 Work
type Worker interface {
	Work()
}

type Stoper interface {
	Stop()
}

// programmer 结构体代表一个程序员
type programmer struct {
	Java   string
	Linux  string
	Python string
}

// Work 实现了 Worker 接口的方法
func (p *programmer) Work() { //指针接收者可以修改字段值
	// 输出程序员的类型和使用的编程语言
	fmt.Printf("小李正在学习%s\n", p.Java)
	fmt.Printf("小张正在学习%s\n", p.Linux)
	fmt.Printf("小王正在学习%s\n", p.Python)
}
func (p programmer) Stop() { //值接收者不修改字段值
	fmt.Printf("小李已经停止学习%s\n", p.Java)
	fmt.Printf("小张已经停止学习%s\n", p.Linux)
	fmt.Printf("小王已经停止学习%s\n", p.Python)
}
func main() {
	// 创建一个 programmer 实例，并初始化字段
	myProgrammer := programmer{
		Java:   "Java语言",
		Linux:  "Linux运维",
		Python: "Python语言",
	}
	x1 := programmer{} // 接口变量赋值也叫实现结构体

	var Myworker Worker = &myProgrammer // 接口变量赋值也叫实现结构体
	Myworker.Work()                     //调用接口方法
	time.Sleep(time.Second * 2)
	x1.Stop()
}

多个类型实现一个接口

 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


package main

import (
	"fmt"
)

// Worker 接口定义了一个方法 Work
type Worker interface {
	Work()
}

// programmer 结构体代表一个程序员
type programmer struct {
	Python string
}
type older struct {
	age int
}

func (p programmer) Work() {
	fmt.Printf("%s的程序员正在工作", p.Python)
	fmt.Println("") //换行
}
func (o older) Work() {
	fmt.Printf("%d岁的程序员正在工作", o.age)
}
func main() {
	// 创建一个 programmer 实例，并初始化字段
	myProgrammer := programmer{
		Python: "Python",
	}
	o := older{age: 20}
	var Myworker Worker = &myProgrammer // 接口变量赋值也叫实现结构体
	Myworker.Work()                     //调用接口方法
	o.Work()
}

接口的嵌套

 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


package main

import (
	"fmt"
)

// Worker 接口定义了一个方法 Work
type Worker interface {
	Work()
}
type Moyuer interface {
	Moyu()
}
type Peoler interface {
	Worker
	Moyuer
}
type Computer struct {
	something string
}

func (c *Computer) Work() {
	fmt.Printf("%s都要工作\n", c.something)
}
func (c *Computer) Moyu() {
	fmt.Printf("%s也要摸鱼\n", c.something)
}

func main() {
	sth := Computer{something: "程序员"}
	x := &sth
	x.Work()
	x.Moyu()
}

空接口

信息

空接口类型的变量可以存储任意类型的变量。

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


package main

import (
	"fmt"
)

func main() {
	var x interface{}
	v1 := "程序猿"
	v2 := 200
	v3 := true
	x = v1
	fmt.Printf("%T类型 : %v\n", x, x)
	x = v2
	fmt.Printf("%T类型 : %v\n", x, x)
	x = v3
	fmt.Printf("%T类型 : %v\n", x, x)
}

信息

因为可以存储任意类型的变量，所以我们把他当做方法中的参数使用。

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


package main

import (
	"fmt"
)

func test(w interface{}) {
	fmt.Printf("Hello %s", w)
}
func main() {
	words := "Golang"
	test(words)
} //Hello Golang

类型断言

信息

类型断言的作用就是判断空接口的值和值的类型

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


package main

import (
	"fmt"
)

func main() {
	var words interface{} = "Golang"
    switch value := words.(type) {            //语法格式为：x.(T)
	case string:
		fmt.Printf("String类型，值为%v", value)
	case int:
		fmt.Printf("Int类型，值为%v", value)
	case bool:
		fmt.Printf("Bool类型，值为%v", value)
	}

}