背景

很多从java开发的同学转到go语言上面往往会有一个困惑，在go语言上面怎么实现跟java一样的封装、继承与多态。go语言并不是面向对象的语言，如果要实现类似的能力需要怎么做？

实现

封装

封装主要通过访问权限的控制来实现

java 语言通过private、protected、public、default等修饰符来进行对属性或方法的访问权限控制。
go语言上面并没有提供类似的修饰符，可以利用包的权限来进行权限的控制，定义变量或方法为小写字母开头，则只能所在包能够访问，定义为大写字母开头，则可以挎包调用例如：

// 使用大写字母开头定义，可以被外部包调用
type Event interface {
   Send() string
}

// 使用小写字母开头定义，不能被外部包调用
type config interface {
   load() bool
}

继承

go语言没有继承，要实现类似继承的能力可以通过struct的组合来实现例如：

// 基础事件
type BaseEvent struct{
   name string
   content string
}

// 开始事件，继承了BaseEvent
type StartEvent struct {
   BaseEvent
   StartTime string
}

// 结束事件，继承了BaseEvent
type EndEvent struct {
   BaseEvent
   EndTime string
}

多态

在java中多态的实现是通过extends class 或者 implements interface 实现的，但是在go语言中并没有相关的修饰符，而是通过实现interface定义的方法就是struct实现了接口

例如：

package main

// 定义接口
type Event interface {
   EventType() string
   Content() string
}

// 定义 StartEvent 结构体
type StartEvent struct {
   typeName string
   content  string
}

// StartEvent结构体实现Event接口的EventType函数
func (e *StartEvent) EventType() string {
   return e.typeName
}

// StartEvent结构体实现Event接口的Content函数
func (e *StartEvent) Content() string {
   return e.content
}

// 定义 EndEvent 结构体
type EndEvent struct {
   typeName string
   content  string
}

// EndEvent结构体实现Event接口的EventType函数
func (e *EndEvent) EventType() string {
   return e.typeName
}

// EndEvent结构体实现Event接口的Content函数
func (e *EndEvent) Content() string {
   return e.content
}

// 定义工厂结构体
type Factory struct {
}

// 根据不同事件类型创建对象
func (e *Factory) Create(eventType string) Event {
   switch eventType {
   case "StartEvent":
      return &StartEvent{
         typeName: "start",
         content:  "开始事件",
      }
   case "EndEvent":
      return &EndEvent{
         typeName: "End",
         content:  "结束事件",
      }
   }
   return nil
}

func main() {
   // 工厂方法模式
   factory :=Factory{}
   startEvent := factory.Create("StartEvent")
   startEvent.Content()
}

Go 语言实现封装，继承与多态

背景

实现

封装

继承

多态