Golang以匿名组合的方式实现继承

匿名组合

具体参见：https://blog.csdn.net/wangkai_123456/article/details/107894993

继承

Golang提供了继承机制，但采用匿名组合的方式实现。

非指针方式组合

示例如下

// 基类
type Base struct {
    // 成员变量
}

func (b *Base) 函数名(参数列表) (返回值列表) {
    // 函数体
}

// 派生类
type Derived struct {
    Base
    // 成员变量
}

func (b *Derived) 函数名(参数列表) (返回值列表) {
    // 函数体
}

继承规则

• 在派生类没有改写基类的成员方法时，相应的成员方法被继承。
• 派生类可以直接调用基类的成员方法，譬如基类有个成员方法为Base.Func()，那么Derived.Func()等同于Derived.Base.Func()
• 倘若派生类的成员方法名与基类的成员方法名相同，那么基类方法将被覆盖或叫隐藏，譬如基类和派生类都有成员方法Func()，那么Derived.Func()将只能调用派生类的Func()方法，如果要调用基类版本，可以通过Derived.Base.Func()来调用。

代码示例

package main

import "fmt"

type Base struct {
}

func (b *Base) Func1() {
	fmt.Println("Base.Func1() was invoked!")
}

func (b *Base) Func2() {
	fmt.Println("Base.Func2() was invoked!")
}

type Derived struct {
	Base
}

func (d *Derived) Func2() {
	fmt.Println("Derived.Func2() was invoked!")
}

func (d *Derived) Func3() {
	fmt.Println("Derived.Func3() was invoked!")
}

func main() {
	d := &Derived{}
	d.Func1()      // Base.Func1() was invoked!
	d.Base.Func1() // Base.Func1() was invoked!

	d.Func2()      // Derived.Func2() was invoked!
	d.Base.Func2() // Base.Func2() was invoked!

	d.Func3() // Derived.Func3() was invoked!
}

##指针方式组合
示例如下

// 基类
type Base struct {
    // 成员变量
}

func (b *Base) 函数名(参数列表) (返回值列表) {
    // 函数体
}

// 派生类
type Derived struct {
    *Base
    // 成员变量
}

func (b *Derived) 函数名(参数列表) (返回值列表) {
    // 函数体
}

继承规则

• 基类采用指针方式的组合，依然具有派生的效果，只是派生类创建实例的时候需要外部提供一个基类实例的指针。
• 其他规则与非指针方式组合一致。

代码示例

package main

import (
	"fmt"
	"log"
	"os"
)

type MyJob struct {
	Command string
	*log.Logger
}

func (job *MyJob) Start() {
	job.Println("job started!") // job.Logger.Println

	fmt.Println(job.Command)

	job.Println("job finished!") // job.Logger.Println
}

func main() {
	logFile, err := os.OpenFile("./job.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0)
	if err != nil {
		fmt.Println("%s", err.Error())
		return
	}
	defer logFile.Close()

	logger := log.New(logFile, "[info]", log.Ldate|log.Ltime|log.Llongfile)
	job := MyJob{"programming", logger}

	job.Start()
	job.Println("test finished!") // job.Logger.Println
}

在经过合适的赋值后，MyJob类型的所有成员方法可以很方便地借用所有log.Logger提供的方法。这对于MyJob的实现者来说，根本就不用意识到log.Logger类型的存在，这就是匿名组合的一个魅力所在。