Golang

面向对象编程

type

利用 type 可以声明某个类型的别名（理解为声明一种新的数据类型）

type myint int

func main() {
  	var a myint = 10
		fmt.Println("a = ", a)
		fmt.Printf("type of a = %T\n", a)
}

a =  10
type of a = main.myint

方法

方法：包含了接受者的函数，接受者可以是命名类型或结构体类型的值或者指针。

方法和普通函数的区别：

对于普通函数，参数为值类型时，不能将指针类型的数据直接传递，反之亦然。
对于方法，接收者为值类型时，可以直接用指针类型的变量调用方法（反过来也可以）。

// 1.普通函数
// 接收值类型参数的函数
func valueIntTest(a int) int {
	return a + 10
}

// 接收指针类型参数的函数
func pointerIntTest(a *int) int {
	return *a + 10
}

func structTestValue() {
	a := 2
	fmt.Println("valueIntTest:", valueIntTest(a))
	// 函数的参数为值类型，则不能直接将指针作为参数传递
	// fmt.Println("valueIntTest:", valueIntTest(&a))
	// compile error: cannot use &a (type *int) as type int in function argument

	b := 5
	fmt.Println("pointerIntTest:", pointerIntTest(&b))
	// 同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递
	// fmt.Println("pointerIntTest:", pointerIntTest(b))
	// compile error:cannot use b (type int) as type *int in function argument
}

struct

一道 struct 与指针面试题：

type student struct {
	name string
	age  int
}

func main() {
	m := make(map[string]*student)
	stus := []student{
		{name: "aaa", age: 18},
		{name: "bbb", age: 23},
		{name: "ccc", age: 28},
	}
	for _, stu := range stus {
		m[stu.name] = &stu
	}
	for k, v := range m {
		fmt.Println(k, "=>", v.name)
	}
}

aaa => ccc
bbb => ccc
ccc => ccc

解决方法 1：

for _, stu := range stus {
  // 方法1
  temp := stu
  m[stu.name] = &temp
}

解决方法 2：

for i, stu := range stus {
  // 方法2
  m[stu.name] = &stus[i]
}

封装

Golang 中，类名、属性名、⽅法名 首字⺟大写 表示对外（其他包）可以访问，否则只能够在本包内访问。

继承

Golang 通过匿名字段实现继承的效果

多态

Golang 中多态的基本要素：

有一个父类（有接口）

// 本质是一个指针
type AnimalIF interface {
	Sleep()
	GetColor() string //  获取动物的颜色
	GetType() string  // 获取动物的种类
}

有子类（实现了父类的全部接口）

// 具体的类
type Cat struct {
	color string // 猫的颜色
}

func (c *Cat) Sleep() {
	fmt.Println("Cat is Sleep")
}

func (c *Cat) GetColor() string {
	return c.color
}

func (c *Cat) GetType() string {
	return "Cat"
}

父类类型的变量（指针）指向（引用）子类的具体数据变量

// 接口的数据类型，父类指针
var animal AnimalIF
animal = &Cat{"Green"}
animal.Sleep() // 调用的就是Cat的Sleep()方法, 多态

不同接收者实现接口

type Mover interface {
	move()
}

type dog struct {
	name string
}

值类型接收者实现接口：可以同时接收值类型和指针类型。

Go 语言中有对指针类型变量求值的语法糖，dog 指针 dog2 内部会自动求值 *dog2

指针类型接收者实现接口：只能接收指针类型。

通用万能类型

interface{} 表示空接口，可以用它引用任意类型的数据类型。

// interface{}是万能数据类型
func myFunc(arg interface{}) {
	fmt.Println(arg)
}

type Book struct {
	auth string
}

func main() {
	book := Book{"Golang"}

	myFunc(book)
	myFunc(100)
	myFunc("abc")
	myFunc(3.14)
}

Golang 给 interface{} 提供类型断言机制，用来区分此时引用的类型：

注意断言这个操作会有两个返回值

func myFunc(arg interface{}) {
  // 类型断言
  value, ok := arg.(string)
  if !ok {
    fmt.Println("arg is not string type")
  } else {
    fmt.Println("arg is string type, value = ", value)
    fmt.Printf("value type is %T\n", value)
  }
}

一个接口的值（简称接口值）是由一个 具体类型 和 具体类型的值 两部分组成的。

这两部分分别称为接口的动态类型和动态值。

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

在这里插入图片描述

switch 判断多个断言：

func justifyType(x interface{}) {
    switch v := x.(type) {
    case string:
        fmt.Printf("x is a string，value is %v\n", v)
    case int:
        fmt.Printf("x is a int is %v\n", v)
    case bool:
        fmt.Printf("x is a bool is %v\n", v)
    default:
        fmt.Println("unsupport type！")
    }
}

反射

变量内置 Pair 结构

在这里插入图片描述

var a string
// pair<statictype:string, value:"aceld">
a = "aceld"

var allType interface{}
// pair<type:string, value:"aceld">
allType = a

str, _ := allType.(string)

类型断言其实就是根据 pair 中的 type 获取到 value

// tty: pair<type: *os.File, value: "/dev/tty" 文件描述符>
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
  fmt.Println("open file error", err)
  return
}

// r: pair<type: , value: >
var r io.Reader
// r: pair<type: *os.File, value: "/dev/tty" 文件描述符>
r = tty

// w: pair<type: , value: >
var w io.Writer
// w: pair<type: *os.File, value: "/dev/tty" 文件描述符>
w = r.(io.Writer) // 强转

w.Write([]byte("HELLO THIS IS A TEST!!\n"))

仔细分析下面的代码：

由于 pair 在传递过程中是不变的，所以不管 r 还是 w，pair 中的 tpye 始终是 Book
又因为 Book 实现了 Reader、Wrtier 接口，所以 type 为 Book 可以调用 ReadBook() 和 WriteBook()

type Reader interface {
	ReadBook()
}

type Writer interface {
	WriteBook()
}

// 具体类型
type Book struct {
}

func (b *Book) ReadBook() {
	fmt.Println("Read a Book")
}

func (b *Book) WriteBook() {
	fmt.Println("Write a Book")
}

func main() {
	// b: pair<type: Book, value: book{} 地址>
	b := &Book{}

	// book ---> reader
	// r: pair<type: , value: >
	var r Reader
	// r: pair<type: Book, value: book{} 地址>
	r = b
	r.ReadBook()

	// reader ---> writer
	// w: pair<type: , value: >
	var w Writer
	// w: pair<type: Book, value: book{} 地址>
	w = r.(Writer) // 此处的断言为什么成功？因为 w, r 的type是一致的
	w.WriteBook()
}

reflect

reflect 包中的两个重要方法：

// ValueOf returns a new Value initialized to the concrete value
// stored in the interface i. ValueOf(nil) returns the zero Value.
func ValueOf(i interface{}) Value {...}

// ValueOf接口用于获取输入参数接口中的数据的值，如果接口为空则返回0

// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {...}

// TypeOf用来动态获取输入参数接口中的值的类型，如果接口为空则返回nil

反射的应用：

获取简单变量的类型和值：

func reflectNum(arg interface{}) {
	fmt.Println("type : ", reflect.TypeOf(arg))
	fmt.Println("value : ", reflect.ValueOf(arg))
}

func main() {
	var num float64 = 1.2345
	reflectNum(num)
}

type :  float64
value :  1.2345

获取结构体变量的字段方法：
- 通过type获取里面的字段
- 1.获取interface的reflect.Type，通过Type得到NumField，进行遍历
- 2.得到每个field，数据类型
- 3.通过field有一个Interface()方法，得到对应的value

结构体标签

结构体标签的定义：

type resume struct {
	Name string `info:"name" doc:"我的名字"`
	Sex  string `info:"sex"`
}

func findTag(str interface{}) {
	t := reflect.TypeOf(str).Elem()

	for i := 0; i < t.NumField(); i++ {
		taginfo := t.Field(i).Tag.Get("info")
		tagdoc := t.Field(i).Tag.Get("doc")
		fmt.Println("info: ", taginfo, " doc: ", tagdoc)
	}
}

func main() {
	var re resume
	findTag(&re)
}