Golang Devops项目开发_golang开发devops

2.8 数据类型和操作符1

2.8 数据类型和操作符2

3. 数字类型，主要有int、int8、int16、int32、int64、uint8、uint16、uint32、uint64、

float32、float64

4. 类型转换，type(variable），比如：var a int=8; var b int32=int32(a)

package main
func main() {
var a int
var b int32
a = 15
b = a + a // compiler error cannot use a + a (value of type int) as int32 value in assignment
b = b + 5 // ok: 5 is a constant
}

package main
 
import (
	"fmt"
	"math/rand"
	"time"
)
 
func init() {
	rand.Seed(time.Now().UnixNano())
}
 
func main() {
 
	for i := 0; i < 10; i++ {
		a := rand.Int()
		fmt.Println(a)
	}
 
	for i := 0; i < 10; i++ {
		a := rand.Intn(100)
		fmt.Println(a)
	}
 
	for i := 0; i < 10; i++ {
		a := rand.Float32()
		fmt.Println(a)
	}
 
}

2.8 数据类型和操作符3

5. 字符类型：var a byte

var a byte = ‘c’

6. 字符串类型： var str string

package main
 
import (
	"fmt"
	"strings"
	"unsafe"
	_ "unsafe"
)
 
func test1() {
	bytes := []byte("I am byte array !")
	str := string(bytes)
	bytes[0] = 'i' //注意这一行，bytes在这里修改了数据，但是str打印出来的依然没变化，
	fmt.Println(str)
}
func test2() {
	bytes := []byte("I am byte array !")
	str := (*string)(unsafe.Pointer(&bytes))
	bytes[0] = 'i'
	fmt.Println(*str)
}
func test3() {
	var data [10]byte
	data[0] = 'T'
	data[1] = 'E'
	var str string = string(data[:])
	fmt.Println(str)
}
 
func str2bytes(s string) []byte {
	x := (*[2]uintptr)(unsafe.Pointer(&s))
	h := [3]uintptr{x[0], x[1], x[1]}
	return *(*[]byte)(unsafe.Pointer(&h))
}
 
func bytes2str(b []byte) string {
	return *(*string)(unsafe.Pointer(&b))
}
func test4() {
	s := strings.Repeat("abc", 3)
	fmt.Println("str2bytes")
	b := str2bytes(s)
	fmt.Println("bytes2str")
	s2 := bytes2str(b)
	fmt.Println(b, s2)
}
 
func main() {
	test1()
	test2()
	test3()
	test4()
}

package main
 
import "fmt"
 
func main() {
	var str = "hello world\n\n"
	var str2 = `hello \n \n \n
	this is a test string
	This is a test string too·`
	fmt.Println("str=", str)
	fmt.Println("str2=", str2)
}

package main
 
import (
	"fmt"
)
 
func test_switch1() {
	a := 2
	switch a {
	case 1:
		fmt.Println("a=1")
	case 2:
		fmt.Println("a=2")
	case 3:
		fmt.Println("a=3")
	case 4:
		fmt.Println("a=4")
	default:
		fmt.Println("default")
	}
}
 
func test_switch2() {
	a := 2
	switch a {
	case 1:
		fmt.Println("a=1")
	case 2:
		fmt.Println("a=2")
		fallthrough
	case 3:
		fmt.Println("a=3")
	case 4:
		fmt.Println("a=4")
	default:
		fmt.Println("default")
	}
}
 
func main() {
	fmt.Printf("执行test_switch%d\n", 1)
	test_switch1()
	fmt.Printf("执行test_switch%d\n", 2)
	test_switch2()
}

package main
 
import "fmt"
 
func modify(p *int) {
 
	fmt.Println(p)
	*p = 1000900
	return
}
 
func main() {
 
	var a int = 10
	fmt.Println(&a)
 
	var p *int
	p = &a
 
	fmt.Println("the address of p:", &p)
	fmt.Println("the value of p:", p)
	fmt.Println("the value of p point to variable:", *p)
 
	fmt.Println(*p)
	*p = 100
	fmt.Println(a)
 
	var b int = 999
	p = &b
	*p = 5
 
	fmt.Println(a)
	fmt.Println(b)
 
	modify(&a)
	fmt.Println(a)
}

package main
 
import (
	"fmt"
	"reflect"
)
 
func add(a, b int) int {
	return a + b
}
func main() {
	c := add
	fmt.Println(c)
	sum := c(10, 20)
	fmt.Println(sum)
	sf1 := reflect.ValueOf(c)
	sf2 := reflect.ValueOf(add)
	if sf1 == sf2 {
		fmt.Println("c equal add")
	}
 
}

package main
 
import (
	"fmt"
)
 
type add_func func(int, int) int
 
func add(a, b int) int {
	return a + b
}
func operator(op add_func, a int, b int) int {
	return op(a, b)
}
func main() {
	c := add
	fmt.Println(c)
	sum := operator(c, 100, 200)
	fmt.Println(sum)
}

package main
 
import "fmt"
 
func modify(a int) {
	a = 100
}
func main() {
	a := 8
	fmt.Println(a)
	modify(a)
	fmt.Println(a)
}

package main
 
import "fmt"
 
func add(a int, arg ...int) int {
	var sum int = a
	for i := 0; i < len(arg); i++ {
		sum += arg[i]
	}
 
	return sum
}
 
func concat(a string, arg ...string) (result string) {
 
	result = a
	for i := 0; i < len(arg); i++ {
		result += arg[i]
	}
 
	return
}
 
func main() {
	sum := add(10, 3, 3, 3, 3)
	fmt.Println(sum)
 
	res := concat("hello", " ", "world")
	fmt.Println(res)
}

4.5 new和make的区别

new

func main() {

var i *int

i=new(int)

*i=10

fmt.Println(*i)

}

 make

func make(t Type, size ...IntegerType) Type func new(Type) *Type

make也是用于内存分配的，但是和new不同，它只用于

chan、map以及切片的内存创建，而且它返回的类型就是这

三个类型本身，而不是他们的指针类型，因为这三种类型

就是引用类型，所以就没有必要返回他们的指针了。

5. Go test方法

5 Go test

前置条件：

1、文件名须以"_test.go"结尾

2、方法名须以"Test"打头，并且形参为 (t *testing.T)

5 Go test 举例

举例：gotest.go

package mytest

import (

"errors"

)

func Division(a, b float64) (float64, error) {

if b == 0 {

return 0, errors.New("除数不能为0")

}

return a / b, nil

}

gotest_test.go

package mytest

import (

"testing"

)

func Test_Division_1(t *testing.T) {

if i, e := Division(6, 2); i != 3 || e != nil { //try a unit test on function

t.Error("除法函数测试没通过") // 如果不是如预期的那么就报错

} else {

t.Log("第一个测试通过了") //记录一些你期望记录的信息

}

}

func Test_Division_2(t *testing.T) {

if _, e := Division(6, 0); e == nil { //try a unit test on function

t.Error("Division did not work as expected.") // 如果不是如预期的那么就

报错

} else {

t.Log("one test passed.", e) //记录一些你期望记录的信息

}

}

5 Go test 测试

1. 在目录下执行 go test 是测试目录所有以XXX_test.go 结尾的文件。

2.测试单个方法

go test -v -run="Test_Division_1" -count 5

3.查看帮助 go help test

package mytest
 
import (
	"testing"
)
 
func Test_Division_1(t *testing.T) {
	if i, e := Division(6, 2); i != 3 || e != nil { //try a unit test on function
		t.Error("除法函数测试没通过") // 如果不是如预期的那么就报错
	} else {
		t.Log("第一个测试通过了") //记录一些你期望记录的信息
	}
}
 
func Test_Division_2(t *testing.T) {
	if _, e := Division(6, 0); e == nil { //try a unit test on function
		t.Error("Division did not work as expected.") // 如果不是如预期的那么就报错
	} else {
		t.Log("one test passed.", e) //记录一些你期望记录的信息
	}
}

5 Go test 命令介绍1

通过go help test可以看到go test的使用说明：

格式形如：

go test [-c] [-i] [build flags] [packages] [flags for test binary]

参数解读：

-c : 编译go test成为可执行的二进制文件，但是不运行测试。

-i : 安装测试包依赖的package，但是不运行测试。

关于build flags，调用go help build，这些是编译运行过程中需要使用到的参数，一般设置为空

关于packages，调用go help packages，这些是关于包的管理，一般设置为空

关于flags for test binary，调用go help testflag，这些是go test过程中经常使用到的参数

-test.v : 是否输出全部的单元测试用例（不管成功或者失败），默认没有加上，所以只输出失败的单元测试用例。

-test.run pattern: 只跑哪些单元测试用例

-test.bench patten: 只跑那些性能测试用例

-test.benchmem : 是否在性能测试的时候输出内存情况

-test.benchtime t : 性能测试运行的时间，默认是1s

-test.cpuprofile cpu.out : 是否输出cpu性能分析文件

-test.memprofile mem.out : 是否输出内存性能分析文件

5 Go test 命令介绍2-续

-test.blockprofile block.out : 是否输出内部goroutine阻塞的性能分析文件

-test.memprofilerate n : 内存性能分析的时候有一个分配了多少的时候才打点记录的问题。这个参数就是设置打

点的内存分配间隔，也就是profile中一个sample代表的内存大小。默认是设置为512 * 1024的。如果你将它设置

为1，则每分配一个内存块就会在profile中有个打点，那么生成的profile的sample就会非常多。如果你设置为0，

那就是不做打点了。

你可以通过设置memprofilerate=1和GOGC=off来关闭内存回收，并且对每个内存块的分配进行观察。

-test.blockprofilerate n: 基本同上，控制的是goroutine阻塞时候打点的纳秒数。默认不设置就相当于-

test.blockprofilerate=1，每一纳秒都打点记录一下

-test.parallel n : 性能测试的程序并行cpu数，默认等于GOMAXPROCS。

-test.timeout t : 如果测试用例运行时间超过t，则抛出panic

-test.cpu 1,2,4 : 程序运行在哪些CPU上面，使用二进制的1所在位代表，和nginx的nginx_worker_cpu_affinity是一个道理

-test.short : 将那些运行时间较长的测试用例运行时间缩短

1.2 Go语言接口与反射

Go语言接口与反射

1. 结构

2. 接口

3. 反射

1. 结构

1.1 struct简介

◼ Go通过结构体struct和interface实现oop(面向对象编程）

◼ struct的成员(也叫属性或字段)可以是任何类型，如普通类型、复合类型、函数、map、interface、

struct等

1.2 struct详解-struct定义

1.2 struct详解-声明与初始化

声明与初始化

var stu1 Student

var stu2 *Student= &Student{} //简写stu2 := &Student{}

var stu3 *Student = new(Student) //简写stu3 := new(Student)

1.2 struct详解-struct使用

var stu1 Student
stu1.age = 34
stu1.name = "dar"
stu1.Class = "class1"
fmt.Println(stu1.name) //dar
var stu2 *Student = new(Student)
stu2.name = "ki"
stu2.age = 33
fmt.Println(stu2.name, (*stu2).name) //ki
var stu3 *Student = &Student{name: "rose", age: 18, Class: "class3"}
fmt.Println(stu3.name, (*stu3).name) //rose rose

package main
 
import (
	"fmt"
	"unsafe"
)
 
type Student struct {
	name  string
	age   int32  // 小写 私密 只能在自己的包里面用
	Class string // 大写 公开 类似C++  public
}
 
func main() {
	// 1 值形式
	var stu1 Student // 里面的变量全是零 栈上的
	fmt.Println("stu1:", stu1)
	stu1.age = 34
	stu1.name = "dar"
	stu1.Class = "class1"
	fmt.Println(stu1.name) //dar
 
	// 2 new 函数创建
	var stu2 *Student = new(Student) // new出来的是堆上
	stu2.name = "king"
	stu2.age = 33
	fmt.Println(stu2.name, (*stu2).name) //king
 
	// &形式创建
	var stu3 *Student = &Student{
		name:  "rose",
		age:   18,
		Class: "class3", // 如果分行的时候每行都要,
	}
	// var stu3 *Student = &Student{name: "rose", age: 18, Class: "class3"}
	fmt.Println(stu3.name, (*stu3).name) //rose  rose
	fmt.Printf("addr: %p, %p, %p\n", &stu1, stu2, stu3)
 
	// 值 初始化
	var stu4 Student = Student{ // KV 形式初始化值
		name:  "老师",
		age:   18,
		Class: "Go", // 注意这里的逗号不能少
	}
	fmt.Println("stu4:", stu4) // stu4: {柚子老师 18 }
 
	// 值顺序初始化
	var stu5 Student = Student{ // 顺序形式 形式初始化值
		"1",
		18,
		"音视频", // 注意这里的逗号不能少
	}
	fmt.Println("stu5:", stu5)
 
	// nil结构体
	var stu6 *Student = nil
	fmt.Println("stu6:", stu6)
 
	// 结构体大小
	fmt.Println("unsafe.Sizeof(stu5):", unsafe.Sizeof(stu5))
	fmt.Println("unsafe.Sizeof(stu6):", unsafe.Sizeof(stu6))
	// fmt.Println("unsafe.Sizeof(string):", unsafe.Sizeof(string))
	// fmt.Println("unsafe.Sizeof(int):", unsafe.Sizeof(int))
}

func Newstu(name1 string,age1 int,class1 string) *Student {

    return &Student{name:name1,age:age1,Class:class1}

    }

    func main() {

    stu1 := Newstu(“dar",34,"math")

    fmt.Println(stu1.name) // dar

    }

package main
 
import "fmt"
 
type Student struct {
	name  string
	age   int
	Class string
}
 
func Newstu(name1 string, age1 int, class1 string) *Student {
	return &Student{name: name1, age: age1, Class: class1}
}
func main() {
	stu1 := Newstu("dar", 34, "math")
	fmt.Println(stu1.name) // dar
}

1.3 struct tag

◼ tag可以为结构体的成员添加说明或者标签便于使用,这些说明可以通过反射获取到。

◼ 结构体中的成员首字母小写对外不可见，但是我们把成员定义为首字母大写这样与外界进行数据

交互会带来极大的不便，此时tag带来了解决方法

type Student struct {

    Name string "the name of student"

    Age int "the age of student"

    Class string "the class of student"

   }

1.3 struct tag –应用场景json示例

应用场景示例，json序列化操作（序列化和反序列化演示）

type Student struct {
	Name string `json:"name"`
	Age int `json:"age"`
	}
	func main() {
	var stu = Student{Name: "dar", Age: 34}
	data, err := json.Marshal(stu)
	if err != nil {
	fmt.Println("json encode failed err:", err)
	return
	}
	fmt.Println(string(data)) //{"name":"dar","age":34}
	}

package main
 
import (
	"encoding/json"
	"fmt"
)
 
// stu:  序列化后：{"name":"dar","age":34}
// 				 {"name1":"dar","age2":34}
type Student struct {
	Name string `json:"name1"`
	Age  int    `json:"age2"`
}
 
func main() {
	var stu = Student{Name: "dar", Age: 34}
	data, err := json.Marshal(stu) //   {"name1":"dar","age2":34}
	if err != nil {
		fmt.Println("json encode failed err:", err)
		return
	}
	fmt.Println("stu: ", string(data)) //{"name":"dar","age":34}
 
	var stu2 Student
	err = json.Unmarshal(data, &stu2) // 反序列化 
	fmt.Println("stu2: ", stu2)       // {dar 34}
}

1.4 struct匿名成员（字段、属性)

◼ 结构体中，每个成员不一定都有名称，也允许字段没有名字，即匿名成员。

◼ 匿名成员的一个重要作用，可以用来实现oop中的继承。

◼ 同一种类型匿名成员只允许最多存在一个。

◼ 当匿名成员是结构体时，且两个结构体中都存在相同字段时，优先选择最近的字段。

type Person struct {

    Name string

    Age int

    }

    type Student struct {

    score string

    Age int

    Person // 匿名内嵌结构体

    }

func main() {
	var stu = new(Student)
	stu.Age = 34                         //优先选择Student中的Age
	fmt.Println(stu.Person.Age, stu.Age) // 0,34
}

// 1.4 struct匿名成员（字段、属性)
 
package main
 
import "fmt"
 
type Person struct {
	Name string
	Age  int
}
type Student struct {
	score  string
	Age    int
	Person // 匿名内嵌结构体
}
 
func main() {
	var stu = new(Student)
	stu.Age = 22                         //优先选择Student中的Age
	fmt.Println(stu.Person.Age, stu.Age) // 0,22
 
	var stu2 = Student{
		score: "100",
		Age:   20,
		Person: Person{
			Name: "柚子老师",
			Age:  18,
		},
	}
	fmt.Println("stu2: ", stu2)
}

1.5 struct-继承、多继承

◼ 当结构体中的成员也是结构体时，该结构体就继承了这个结构体，继承了其所有的方法与属性，当然有多个

结构体成员也就是多继承。

◼ 访问父结构中属性也使用“.”，但是当子结构体中存在和父结构中的字段相同时候，只能使用："子结构体.父

结构体.字段"访问父结构体中的属性，如上面示例的stu.Person.Age

◼ 继承结构体可以使用别名，访问的时候通过别名访问，如下面示例man1.job.Salary：

type Person struct {

    Name string

    Age int

    }

    type Teacher struct {

    Salary int

    Classes string

   }

type man struct {
	sex string
	job Teacher //别名，继承Teacher 这个时候就不是匿名了
	Person //继承Person
	}
	func main() {
	var man1 = new(man)
	man1.Age = 34
	man1.Name = "dar"
	man1.job.Salary = 100000
	fmt.Println(man1, man1.job.Salary) //&{ {8500 } {dar 34}} 8500
	}

// 1.5 struct-继承、多继承
package main
 
import "fmt"
 
type Person struct {
	Name string
	Age  int
}
type Teacher struct {
	Salary int
	Class  string
}
 
type Man struct {
	sex    string
	job    Teacher //别名，继承Teacher
	Person         //继承Person
}
 
func main() {
	var man1 = new(Man)
	man1.Age = 34
	man1.Name = "dar"
	man1.job.Salary = 100000
	fmt.Println("man1:", man1, man1.job.Salary) //&{ {8500 } {dar 34}} 8500
 
	var man2 = Man{
		sex: "女",
		job: Teacher{
			Salary: 8000,
			Class:  "班班",
		},
		Person: Person{ // 匿名初始化方式
			Name: "老师",
			Age:  18,
		},
	}
	fmt.Println("man2", man2)
}

1.6 struct-结构体中的方法

方法是什么

◼ Go方法是作用在接受者（个人理解成作用对象）上的一个函数，接受者是某种类型的变量，因此方法是一种特殊

类型的函数。

◼ 接收者可以是任何类型，不仅仅是结构体，Go中的基本类型（int，string，bool等）也是可以，或者说数组的别名

类型，甚至可以是函数类型。但是，接受者不能是一个接口类型，因为接口是一个抽象的定义，方法是一个具体

实现。

◼ 一个类型加上它的方法等价于面向对象中的一个类。一个重要的区别是：在 Go 中，类型的代码和绑定在它上面的

方法的代码可以不放置在一起，它们可以存在在不同的源文件，唯一的要求是：它们必须是同一个包的。

◼ 类型 T（或 *T）上的所有方法的集合叫做类型 T（或 *T）的方法集。

◼ 因为方法是函数，所以同样的，不允许方法重载，即对于一个类型只能有一个给定名称的方法。但是如果基于接

收者类型，是有重载的：具有同样名字的方法可以在 2 个或多个不同的接收者类型上存在，比如在同一个包里这么

做是允许的

◼ 别名类型不能有它原始类型上已经定义过的方法（因为别名类型和原始类型底层是一样的）。

定义方法的格式

func(recv recevier_type(结构体))methodName(parameter_list)(return_value_list){}

1.6 struct-结构体中的方法-示例

type Person struct {

    Name string

    Age int

    }

    func (p Person) Getname() string { //p代表结构体本身的实列，类似python中的self,这里p可以写为self

    fmt.Println(p.Name)

    return p.Name

    }

    func main() {

    var person1 = new(Person)

    person1.Age = 34

    person1.Name = "dar"

    person1.Getname() // dar

    }

结构体的指针方法

package main
 
import (
	"fmt"
	"math"
)
 
type Circle struct {
	x      int
	y      int
	Radius int
}
 
// 面积
func (c Circle) Area() float64 {
	return math.Pi * float64(c.Radius) * float64(c.Radius)
}
 
// 周长
func (c Circle) Circumference() float64 {
	return 2 * math.Pi * float64(c.Radius)
}
 
func (c Circle) expand() {
	c.Radius *= 2
}
 
func (c *Circle) expand2() {
	c.Radius *= 2
}
func main() {
	var c = Circle{Radius: 50}
	fmt.Println(c.Area(), c.Circumference())
	// 指针变量调用方法形式上是一样的
	var pc = &c
	pc.expand2()
	fmt.Println(pc.Area(), pc.Circumference())
 
}

type Person struct {
Name string
Age int
}
func (p Person) Getname() string { //p代表结构体本身的实列，类似python中的self,这里p可以写为self
fmt.Println(p.Name)
return p.Name
}
func main() {
var person1 = new(Person)
person1.Age = 34
person1.Name = "dar"
person1.Getname() // dar
}

1.6 struct-结构体中的方法-方法和函数的区别

◼ 方法只能被其接受者调用

◼ 接收者是指针时，方法可以改变接受者的值（或状态），函数也能做到

◼ 接受者和方法必须在同一个包内

1.6 struct-结构体中的方法-方法的接受者是值或者指针的区别

◼ 当接受者是一个值的时候，这个值是该类型实例的拷贝

◼ 如果想要方法改变接受者的数据，就在接受者的指针类型上定义该方法。否则，就在普

通的值类型上定义方法。

总结：指针方法和值方法都可以在指针或者非指针上被调用。也就是说，方法接收者是

指针类型时，指针类型的值也是调用这个方法，反之亦然。

1.7 struct-内存分布

go中的结构体内存布局和c结构体布局类似，每个成员的内存分布是连续的

type Student struct {
Name string
Age int64
wight int64
high int64
score int64
}

package main
 
import (
	"fmt"
	"reflect"
)
 
// type Student struct {
// 	Name  string // 16
// 	Age   int64  // 8
// 	wight int64  // 8
// 	high  int64  // 8
// 	score int64  // 8
// }
type Student struct {
	Name  string // 16  有两个变量： 指针, length
	Age   int8   //
	wight int64  // 8
	high  int8   // 8
	score int64  // 8
}
 
func main() {
	var stu1 = new(Student)
	stu1.Name = "只为你"
	fmt.Printf("地址分布:")
	fmt.Printf("%p\n", &stu1.Name)
	fmt.Printf("%p\n", &stu1.Age)
	fmt.Printf("%p\n", &stu1.wight)
	fmt.Printf("%p\n", &stu1.high)
	fmt.Printf("%p\n", &stu1.score)
	typ := reflect.TypeOf(Student{})
	fmt.Printf("Struct is %d bytes long\n", typ.Size())
	// We can run through the fields in the structure in order
	n := typ.NumField()
	for i := 0; i < n; i++ {
		field := typ.Field(i) // 反射出filed
		fmt.Printf("%s at offset %v, size=%d, align=%d\n",
			field.Name, field.Offset, field.Type.Size(),
			field.Type.Align())
	}
}

2. 接口

2.1 interface简介

interface(接口)是golang最重要的特性之一，Interface类型可以定义一组方法，但是这些不需要实

现。并且interface不能包含任何变量。

◼ interface 是方法的集合

◼ interface是一种类型，并且是指针类型

◼ interface的 更重要的作用在于多态实现

◼ interface 不能包含任何变量

2.2 interface定义

type 接口名称 interface {

    method1 (参数列表) 返回值列表

    method2 (参数列表) 返回值列表

    ...

    }

2.3 interface使用

◼ 接口的使用不仅仅针对结构体，自定义类型、变量等等都可以实现接口。

◼ 如果一个接口没有任何方法，我们称为空接口，由于空接口没有方法，任意结构体都

隐式地实现了空接口。

◼ 要实现一个接口，必须实现该接口里面的所有方法。

// 2.3 interface使用
 
package main
 
import "fmt"
 
//定义接口
type Skills interface {
	Running()
	Getname() string
}
 
type Student struct {
	Name string
	Age  int
}
 
type Teacher struct {
	Name string
	Age  int
}
 
// 实现接口
func (p Student) Getname() string { //实现Getname方法
	fmt.Println(p.Name)
	return p.Name
}
 
func (p Student) Running() { // 实现 Running方法
	fmt.Printf("%s running\n", p.Name)
}
 
func (p Teacher) Getname() string { //实现Getname方法
	fmt.Println(p.Name)
	return p.Name
}
 
func (p Teacher) Running() { // 实现 Running方法
	fmt.Printf("%s running\n", p.Name)
}
 
func (p Teacher) Running2() { // 实现 Running方法
	fmt.Printf("%s running\n", p.Name)
}
 
// 想用接口，那就要实现对应接口的所有方法
func main() {
	var skill Skills // 一个接口变量
	var stu1 Student // 结构体变量
	stu1.Name = "dar"
	stu1.Age = 34
	skill = stu1
	skill.Running() //调用接口
 
	var teacher Teacher = Teacher{"老师", 18}
	skill = teacher
	skill.Running() //调用接口
	teacher.Running()
}

// 空接口
package main
 
import "fmt"
 
// Go 语言为了避免用户重复定义很多空接口，它自己内置了一个，这个空接口的名字特别奇怪，叫 interface{}
/*
空接口里面没有方法，所以它也不具有任何能力，其作用相当于 Java 的 Object 类型，可以容纳任意对象，
它是一个万能容器。比如一个字典的 key 是字符串，但是希望 value 可以容纳任意类型的对象，
类似于 Java 语言的 Map 类型，这时候就可以使用空接口类型 interface{}。*/
// 空接口 map 里面用
func main() {
	// map  k-v  一个map里面是有key都是同一类型，value也是同一类型
	// map[string]int   k-string  v-int
	// 连续两个大括号，是不是看起来很别扭
	// 代码中 user 字典变量的类型是 map[string]interface{}，
	// 从这个字典中直接读取得到的 value 类型是 interface{}，需要通过类型转换才能得到期望的变量。
	var user = map[string]interface{}{
		"age":     30,
		"address": "Beijing",
		"married": true,
	}
	fmt.Println(user)
	// 类型转换语法来了
	var age = user["age"].(int)
	var address = user["address"].(string)
	var married = user["married"].(bool)
	fmt.Println(age, address, married)
 
	user["price"] = 5.5
	var price = user["price"].(float64) // ？报错?
	fmt.Println("user: ", user, price)
 
	fmt.Println("user2: ")
	var user2 = map[interface{}]interface{}{
		111:        30,
		"address2": "Beijing",
		1.2:        true,
	}
	fmt.Println("user2: ", user2)
}