写在文章开头

面向对象编程最重要的特性就是多态，通俗来说就是根据接口定义的行为进行不同的实现，从而保证代码的可拓展性，而go语言的设计者rob pike也说过：

试图禁止白痴行为的编程语言，本身就是白痴

所以，基于go语言之父的这个说法，笔者也来浅谈一下go语言中的面向对象思想。

我是 SharkChili ，Java 开发者，Java Guide 开源项目维护者。欢迎关注我的公众号：写代码的SharkChili，也欢迎您了解我的开源项目 mini-redis：https://github.com/shark-ctrl/mini-redis (opens new window)。

为方便与读者交流，现已创建读者群。关注下方公众号获取我的联系方式，添加时备注加群即可加入。

详解go语言中的接口

接口的定义

对应的我们给出接口定义的语法格式，代码如下，可以看到我们定义的接口是一个通知者有一个通知的方法，具体实现交由其他结构体：

type notifier interface {
	notify()
}

接口值方法

我们给出一个user类并实现该接口，可以看到go语言的继承和其他语言有所区别，语法格式为：

1. 方法名前方指明类型也就是这个方法所属者即我们的user结构体，这里是类型的值。
2. 方法名及其返回值和interface接口保持一致

对应的我们给出代码示例：

type user struct {
	id   int
	name string
}

func (u user) notify() {
	fmt.Println("user send msg")
}

需要了解的是接收者为值的实现方法及其调用的底层的机制，本质上就是：

1. notifier的接口底层的的iTable指针指向user类型和它的方法集
2. notifier底层的指针pointer指向该类型的地址即我们的user对象地址
3. 上述关联构成一套完成的接口值方法实现

这里我们也给出调用的示例：

func main() {
	u := user{1, "xiaoming"}
	u.notify()
}

对应输出结果如下：

user send msg

接口作为方法参数

经过上述的封装，后续如果我们希望一个方法让notifier接口及其实现类作为入参的方法sendNotification，就可以以接口类型作为入参：

//sendNotification 接口值方法作为入参
func sendNotification(n notifier) {
	n.notify()
}

对应的我们也需要给出调用示例：

func main() {
	u := user{1, "xiaoming"}
	sendNotification(u)
}

输出结果也和预期的一样，输出了一段user实现的notify的打印。

user send msg

接口指针方法

指针接收者方法格式和上述接口值方法差不多，唯一的区别就是类型声明时要制定类型为user指针：

func (u *user) notify() {
	fmt.Println("user send msg")
}

func main() {
	u := user{2, "user2"}
	u.notify()
}

对应内部实现结构图如下，可以看到与接口值方法的区别就是 pointer指向的是user的指针的指针的地址，注意笔者说的，对象指针的指针，所以下图用&(user{......})标识，用C语言的名词描述即二级指针：

我们尝试将接口指针方法的user类型作为入参传入sendNotification 方法：

//接口指针方法
func (u *user) notify() {
	fmt.Println("user send msg")
}

func main() {
	u := user{2, "user2"}
	sendNotification(u)
}

// sendNotification 接口值方法作为入参
func sendNotification(n notifier) {
	n.notify()
}

最终在编译时报错，提示user没有继承notifier ，因为该方法的实现是指针接收者(u *user)：

user does not implement notifier (method notify has pointer receiver)

所以，按照go语言的规定，当接口方法的接收者为值时，那么这个类型指针或者值都可以作为接口的实现，所以我们可以将notify的接受者改为(u user)确保指针和对象都可以直接调用：

//user类
type user struct {
	id   int
	name string
}

// 接口值方法
func (u user) notify() {
	fmt.Println("user send msg")
}

// sendNotification 接口值方法作为入参
func sendNotification(n notifier) {
	n.notify()
}

同样也能作为接口指着的入参：

// user类
type user struct {
	id   int
	name string
}

// 接口值方法
func (u user) notify() {
	fmt.Println("user send msg")
}

// sendNotification 接口指针作为入参
func sendNotification(n *notifier) {
	(*n).notify()
}

当然，读者如果不想修改方法构造，也可以声明一个user指针类型传入sendNotification让user指针发起notify调用也是可以的：

type notifier interface {
	notify()
}

// user类
type user struct {
	id   int
	name string
}

// 接口值方法
func (u *user) notify() {
	fmt.Println(u.name, " send msg")
}

// sendNotification 接口值作为入参
func sendNotification(n notifier) {
	n.notify()
}

func main() {
	u := user{1, "xiaoming"}
	//因为用指针的形式实现方法，所以只有指针类型可以代表接口的实现
	sendNotification(&u)
}

由此我们可以总结出这样一张图，可以看到若实现接口的结构体是接口值方法，那么它的指针和值都可以判定为接口。若是指针接口方法，那么只有它的指针可以判定为接口：

go语言的多态

不同类型实现接口后让iTable指向不同的类型，编译器即可识别这一点从而完成多态，所以我们还是基于notifier接口user和admin两种不同的实现

type user struct {
	id   int
	name string
}

//user的实现
func (u user) notify() {
	fmt.Println("user send msg")
}

type admin struct {
	no int
	u  user
}

//admin1的实现
func (a admin) notify() {
	fmt.Println("admin send msg")
}

对应调用示例：

func sendNotification(n notifier) {
	n.notify()
}

func main() {
	u := user{1, "user"}
	sendNotification(u)
	a := admin{1, user{1, "xiaoming"}}
	sendNotification(a)
}

输出结果:

user send msg
admin send msg

嵌入类型的调用

现在有这样一个场景，我们有个user对象实现了接口，然后admin嵌入这个类型，那么它是否可以调用notify呢：

type notifier interface {
	notify()
}

//user结构体以及接口实现
type user struct {
	id   int
	name string
}

func (u user) notify() {
	fmt.Println("user send msg")
}

//admin聚合了user
type admin struct {
	no int
	user
}

实际上go语言考虑到了这一点，所以在调用时如果为了规范，我们可以通过调用成员变量的方式调用notify，也可以直接调用notify方法(go语言编译时看到admin没有notify的实现，自动将notify提升为user的方法)：

func main() {

	a := admin{1, user{1, "xiaoming"}}
	//通过成员方法的方式调用
	a.user.notify()
	//基于go语言的类型提升调用
	a.notify()
}

对应输出结果如下：

user send msg
user send msg

权限标识

go语言没有权限关键字，假设我们在其他文件夹常见user类，那么我们必须将其命名大写才能被访问到：

package other

type User struct {
	id   int
	Name string
}

对应调用代码如下，可以看到只有大写的变量才能被访问到：

简而言之，对于某个类型的调用，无论是其类型还是变量，如果希望能够被访问修改，就必须以大写的格式声明，这也突出go语言简单的设计理念，即通过变量的大小写决定能否访问。

关于go语言接口与继承更进一步的认识

延迟绑定的继承机制

通过上文几个语法示例和基本介绍，我们大体是了解go语言对于面向对象思想的认同，同时我们也看到go语言的对于继承这一概念，没有非常明显的标注和严格的编译检查。

和传统的静态编程语言有所不同，go语言取而代之是是一种安全和灵活的一种灵活的关系理念，即对于继承它的原则是：

只要你看着像、行为也想，那么你就可以把它当做这个类型的继承

例如go语言内置的工具包有一个writer接口的定义如下，通过这个接口及其函数，我们大体知道该接口的特征：

1. 有一个唯一函数Write
2. 入参为[]byte
3. 出参n int, err error

这也就意味，我们的结构体只要具备Writer方法且函数签名和接口一致，那么我们就可以认为我们的结构体继承Writer：

type Writer interface {
	Write(p []byte) (n int, err error)
}

所以，如果我们想继承这个接口并实现一个将数据p转大写输出的结构体，对应的秩序做到：

1. 包含一个函数Write
2. Write入参仅有一个[]byte
3. 返回值包含输出长度n和error(如果存在报错的话)

例如我们想继承Writer实现一个将数据大写输出的Writer方法，那么我们的结构体UpperWriter就可以严格按照函数签名并落地自己的逻辑即可：

于是我们就有了这个一个输出大写data的结构体UpperWriter，可以看到该结构体引入成员变量Writer后，对应的Write方法严格按照Write的签名用内置成员变量Writer实现了一个输出大写data的实现：

type UpperWriter struct {
	io.Writer //成员变量
}

func (w *UpperWriter) Write(data []byte) (n int, err error) { //函数签名和Write一致,构成继承关系
	return w.Writer.Write(bytes.ToUpper(data))
}

对应的goland的编译器也将其视为继承了io.Writer，同样因为这种延迟绑定机制，如果我们希望现有类继承某种新接口，也可以反向根据对象方法签名反向创建接口，避免破坏原有类型的情况下完成反向适配：

隐式转换误继承问题

当然自由也是有代价的，因为只要长得像就可以视为继承，这就是使得我们的编程出现各种误继承，可以看到我们的UpperWriter因为签名和很多接口类似于是就被视为继承：

对应的最佳实践是针对避免接口误继承，对应接口实现可以内置一个特异化标识函数的接口避免误继承，例如我们的Error为了避免其他结构实现了Error() string就被视为继承Error故特异化一个RuntimeError避免误继承：

// The Error interface identifies a run time error.
type Error interface {
	error //error为嵌入类型，代表Error接口有一个方法Error() string

	
	RuntimeError()
}

所以日常的实践中，我们也可以通过针对接口特殊标注避免误继承，例如下面这个Cat因为无意编写了一个返回值为string的eat方法导致误继承了human的行为：

对应的解决策略就是针对human接口指定一个人类特有的阅读行为，避免其他因为无意写了eat导致误继承：

小结

我是 SharkChili ，Java 开发者，Java Guide 开源项目维护者。欢迎关注我的公众号：写代码的SharkChili，也欢迎您了解我的开源项目 mini-redis：https://github.com/shark-ctrl/mini-redis (opens new window)。

为方便与读者交流，现已创建读者群。关注下方公众号获取我的联系方式，添加时备注加群即可加入。

参考

《Go语言实战》 《Go语言高级编程》