编程方式

• 上面的文章通过func函数，使我们可以重复的使用代码，称之为函数式编程
• 面向对象编程：通过对象 + 方法 ，让操作基于一个对象，而不只是来回的掉函数（并且可以使用面向对象的其他优点）

面向对象的优点这里不过多的赘述，感兴趣的自己看下
举个最简单的例子：

func 吃饭(){}
func 睡觉(){}
func 打豆豆(){}

// 如果是小明要吃饭，睡觉、打豆豆，如果用函数的话只能传参！来表示吃饭的是谁、睡觉的是谁，通过函数操作

// 如果是通过对象和方法呢？
xiaohong.吃饭()、xiaohong.睡觉()、xiaohong.打豆豆()   // 通过对象来触发动作、区别于过程和函数，它的操作是某一个对象

go语言对象方法

自定义类型和方法

package main

import "fmt"

func main() {
	var a MyInt = 1
	a.ShowString()
}

// MyInt 自定义的int类型
type MyInt int

// ShowString MyInt的ShowString方法根据对象值输出指定字符串
func (m MyInt) ShowString() {
	fmt.Printf("当前对象的值是:%d\n", m)
}

通过上面的方法可以看出，我们自定义了个类型：MyInt ， 并给MyInt绑定了一个方法：

ShowString它是一个函数，仔细看下它和函数有什么区别

• 函数定义: func 函数名(参数列表) (返回参数) {函数体}
• 方法定义: func (接收器变量 接收器类型) 方法名(参数列表) (返回参数) {函数体}

// ShowString 普通的函数接收一个ShowString的类型参数
func showString(m MyInt) {
	fmt.Printf("当前对象的值是:%d\n", m)
}

// ShowString MyInt的ShowString方法根据对象值输出指定字符串
func (m MyInt) ShowString() {
	fmt.Printf("当前对象的值是:%d\n", m)
}

接收器: 方法作用的目标(类型和方法的绑定)

func (接收器变量 接收器类型) 方法名(参数列表) (返回参数) {
    函数体
}

备注:

• 接收器变量：接收器中的参数变量名在命名时，官方建议使用接收器类型名的第一个小写字母，而不是 self、this 之类的命名。例如，Socket 类型的接收器变量应该命名为 s，Connector 类型的接收器变量应该命名为 c 等
• 接收器类型：接收器类型和参数类似，可以是指针类型和非指针类型
• 方法名、参数列表、返回参数：格式与函数定义一致

例子:

package main

import "fmt"

func main() {
	p1 := &Person{"eson", 2}
	p1.Eat()
	p1.Sleep()
	p1.Play("足球")
}

// Person 自定义的Person类型
type Person struct {
	name string
	age  uint8
}

// Eat Person的吃饭方法
func (p *Person) Eat() {
	fmt.Printf("%s正在吃饭....\n", p.name)
}

// Sleep Person的睡觉方法
func (p *Person) Sleep() {
	fmt.Printf("%s正在睡觉....\n", p.name)
}

// Play Person的玩游戏方法
func (p *Person) Play(game string) {
	fmt.Printf("%s正在玩:%s....\n", p.name, game)
}

go面向对象总结

• 任何自定义类型都可以定义方法（内置类型，接口定义方法不可以自定义方法）
• 方法通过接收者方式和类型进行绑定达到面向对象
• 一般都用struct类型当做方法的接受者 & 并且通过指针来传递类型的值方便修改

方法的继承

在Go中没有extends关键字，也就意味着Go并没有原生级别的继承支持! Go是使用组合来实现的继承，说的更精确一点，是使用组合来代替的继承

package main

import "fmt"

func main() {
	cat := &Cat{
		Animal: &Animal{
			Name: "cat",
		},
	}
	cat.Eat() // cat is eating
}

// Animal 动物的结构体
type Animal struct {
	Name string
}

// Eat 方法与Animal结构体绑定
func (a *Animal) Eat() {
	fmt.Printf("%v is eating", a.Name)
	fmt.Println()
}

// Cat 结构体通过组合的方式实现继承
type Cat struct {
	*Animal
}

go语言接口

在Go语言中接口（interface）是一种类型，一种抽象的类型

interface是一组方法的集合，它不关心属性（数据），只关心行为（方法），它类似规则标准

为什么要用接口

场景: 我有一个发送短信告警的代码如下，现在来个新人要新增微信的告警
问题:

• 逻辑代码产生了冗余，逻辑都是一样的：写库、判断是否发送告警、发送告警，每个类型的告警都要写一遍

• 一点约束都没有，不管是参数还是方法名字（增加了后期阅读和维护成本）

接口可以搞定上面的问题

package main

import "fmt"

func main() {

	var input string
	fmt.Scanln(&input)
	// 接收一个告警消息，接收到后需要做
	// 写库
	// 判断这个模块告警是否关闭(需要发送)
	// 发送告警

	switch input {
	case "smse":
		// 短信告警
		alarms := &SmsAlarms{ModuleName: "nginx", PhoneNumber: 1234567890}
		// 写库
		alarms.InsertAlarm()
		isSend := alarms.IsAlarm()
		if isSend {
			// 如果需要发送告警就发送
			alarms.SendAlarm()
		}
	case "wechat":
		// 短信告警
		alarms := &WechatAlarms{ModuleName: "nginx", Account: "test@qq.com"}
		// 写库
		alarms.InputAlarm()
		isSend := alarms.IAlarm()
		if isSend {
			// 如果需要发送告警就发送
			alarms.SAlarm()
		}
	}

}

// SmsAlarms 短信告警
type SmsAlarms struct {
	ModuleName  string
	PhoneNumber int
}

// InsertAlarm 短信告警的写库方法
func (s *SmsAlarms) InsertAlarm() {
	fmt.Printf("伪代码逻辑:短信告警--->模块:%s 把告警写入数据库\n", s.ModuleName)
}

// IsAlarm 短信告警判断这个模块告警是否关闭(需要发送)
func (s *SmsAlarms) IsAlarm() bool {
	fmt.Printf("伪代码逻辑:短信告警--->模块:%s 判断模块是否关闭告警\n", s.ModuleName)
	return true
}

// SendAlarm 短信告警发送
func (s *SmsAlarms) SendAlarm() {
	fmt.Printf("伪代码逻辑:短信告警--->模块:%s 告警发送完毕....\n", s.ModuleName)
}

// WechatAlarms 微信告警
type WechatAlarms struct {
	ModuleName string
	Account    string
}

// InputAlarm 微信告警的写库方法
func (s *WechatAlarms) InputAlarm() {
	fmt.Printf("伪代码逻辑:微信告警--->模块:%s 把告警写入数据库\n", s.ModuleName)
}

// IAlarm 短信告警判断这个模块告警是否关闭(需要发送)
func (s *WechatAlarms) IAlarm() bool {
	fmt.Printf("伪代码逻辑:微信告警--->模块:%s 判断模块是否关闭告警\n", s.ModuleName)
	return true
}

// SAlarm 短信告警发送
func (s *WechatAlarms) SAlarm() {
	fmt.Printf("伪代码逻辑:微信告警--->模块:%s 告警发送完毕....\n", s.ModuleName)
}

接口的定义

type 接口类型名 interface{
    方法名1( 参数列表1 ) (返回值列表1)
    方法名2( 参数列表2 ) 返回值列表2
    …
}

* 接口名: <p style="color:red">接口是一个类型通过type关键字定义</p>, 一般接口名字是er结尾且具有实际的表现意义，比如我下面的例子
* 方法名：首字母大写package外可以访问，否则只能在自己的包内访问
* 参数、返回值名称可以省略，但是类型不能省略比如: call(string) string

```go
// Alerter 告警的接口类型
type Alerter interface {
	InsertAlarm()
	IsAlarm() bool
	SendAlarm()
}

最终实现例子：

package main

import "fmt"

func main() {

	var input string
	fmt.Scanln(&input)

	// 声明告警接口变量
	var alarms Alerter

	switch input {
	case "smse":
		// 短信告警
		alarms = &SmsAlarms{ModuleName: "nginx", PhoneNumber: 1234567890}

	case "wechat":
		// 短信告警
		alarms = &WechatAlarms{ModuleName: "nginx", Account: "test@qq.com"}
	default:
		fmt.Printf("不要发送告警\n")
	}

	// 统一的告警写库方法
	alarms.InsertAlarm()
	// 统一判断是否需要发送告警
	isSend := alarms.IsAlarm()
	if isSend {
		alarms.SendAlarm()
	}
}

// Alerter 告警的接口类型
type Alerter interface {
	InsertAlarm()
	IsAlarm() bool
	SendAlarm()
}

// SmsAlarms 短信告警
type SmsAlarms struct {
	ModuleName  string
	PhoneNumber int
}

// InsertAlarm 短信告警的写库方法
func (s *SmsAlarms) InsertAlarm() {
	fmt.Printf("伪代码逻辑:短信告警--->模块:%s 把告警写入数据库\n", s.ModuleName)
}

// IsAlarm 短信告警判断这个模块告警是否关闭(需要发送)
func (s *SmsAlarms) IsAlarm() bool {
	fmt.Printf("伪代码逻辑:短信告警--->模块:%s 判断模块是否关闭告警\n", s.ModuleName)
	return true
}

// SendAlarm 短信告警发送
func (s *SmsAlarms) SendAlarm() {
	fmt.Printf("伪代码逻辑:短信告警--->模块:%s 告警发送完毕....\n", s.ModuleName)
}

// WechatAlarms 微信告警
type WechatAlarms struct {
	ModuleName string
	Account    string
}

// InsertAlarm 微信告警的写库方法
func (s *WechatAlarms) InsertAlarm() {
	fmt.Printf("伪代码逻辑:微信告警--->模块:%s 把告警写入数据库\n", s.ModuleName)
}

// IsAlarm 微信告警判断这个模块告警是否关闭(需要发送)
func (s *WechatAlarms) IsAlarm() bool {
	fmt.Printf("伪代码逻辑:微信告警--->模块:%s 判断模块是否关闭告警\n", s.ModuleName)
	return true
}

// SendAlarm 微信告警发送
func (s *WechatAlarms) SendAlarm() {
	fmt.Printf("伪代码逻辑:微信告警--->模块:%s 告警发送完毕....\n", s.ModuleName)
}

接口的作用总结

通过上面的例子可以发现，如果想发送告警

• 首先必须遵循接口定义的方法名称和参数，达到了约束

• 后面在想增加其他类型的告警比如邮件告警的时候，代码逻辑哪里只需增加一个email告警的赋值即可，接口约束了告警怎么玩，也简化了重复的逻辑NICE

接口的嵌套

接口与接口间可以通过嵌套创造出新的接口，看下面的例子

package main

import "fmt"

func main() {
	var a Animaler
	a = &Cat{Name: "小花"}
	a.Eat("猫粮")
	a.Walk("花园")

}

// Animaler 定义一动物的接口
type Animaler interface {
	Eater
	Walker
}

// Eater 定义一个吃的接口
type Eater interface {
	Eat(string)
}

// Walker 定义一个行走的接口
type Walker interface {
	Walk(string)
}

// Cat 定义一个猫的结构体
type Cat struct {
	Name string
}

// Eat 小猫的Eat方法
func (c *Cat) Eat(food string) {
	fmt.Printf("小猫:%s正在吃:%s\n", c.Name, food)
}

// Walk 小猫的Walk方法
func (c *Cat) Walk(place string) {
	fmt.Printf("小猫:%s正在%s行走....\n", c.Name, place)
}

空接口

一个类型如果实现了一个 interface 的所有方法就说该类型实现了这个 interface，空的 interface 没有方法，所以可以认为所有的类型都实现了 interface{}
所以：空接口是指没有定义任何方法的接口，因此任何类型都实现了空接口，如下面例子

package main

import "fmt"

func main() {
	var x interface{}

	s := "Hello World"
	x = s
	fmt.Printf("s的类型是: %T, x的类型是: %T, x的值是: %v\n", s, x, x)

	i := 100
	x = i
	fmt.Printf("s的类型是: %T, x的类型是: %T, x的值是: %v\n", s, x, x)
}

空接口的应用场景

• 作为函数的参数类型，让函数可以接收任意类型的类型
• 作为数组、切片、map的元素类型，来增强他们的承载元素的灵活性

一般情况下慎用，如果用不好他会使你的程序非常脆弱

空接口作为函数的参数的类型时

package main

import "fmt"

func main() {
	// 可以传递任意类型的值
	xt("Hello World!")
	xt(100)
}

func xt(x interface{}) {
	fmt.Printf("x的类型是: %T, x的值是:%v\n", x, x)
}

切片或者map的元素类型

package main

import "fmt"

func main() {
	list := []interface{}{10, "a", []int{1, 2, 3}}
	fmt.Printf("%v\n", list)

	info := map[string]interface{}{"age": 18, "addr": "河北", "hobby": []string{"篮球", "旅游"}}
	fmt.Printf("%v\n", info)
}

类型断言

空接口可以存储任意类型的值，如果使用了空接口，如何在运行的时候获取它到底是什么类型的数据呢？

x.(T)

• x：表示类型为interface{}的变量
• T：表示断言x可能是的类型

调用: x.(T)语法后返回两个参：

• 数第一个参数是x转化为T类型后的变量
• 第二个值是一个布尔值(为true则表示断言成功，为false则表示断言失败)

package main

import "fmt"

func main() {
	var x interface{}
	x = "Hello World"
	// x.(T)
	v, ok := x.(string)

	if ok {
		fmt.Printf("类型断言:string, 它的值是:%v\n", v)
	} else {
		fmt.Printf("%v\n", ok)
	}
}

类型断言的本质（感兴趣的可以看下没必要深究）

静态语言在编写、编译的时候可以准确的知道某个变量的类型，那运行中它是如何获取变量的类型的呢？通过类型元数据

每个类型都有自己的类型元数据，我们看看空接口它可以存储任意类型的数据，所以只需要知道

• 存储的类型是是什么
• 存哪里

源码在这里: /usr/local/Cellar/go/1.15.8/libexec/src/runtime/type.go 修改为自己的路径

当我们定义了一个空接口:

Go语言学习之路-11-方法与接口

原文：https://www.cnblogs.com/luotianshuai/p/14311122.html