golang 匿名结构体成员，具名结构体成员，继承，组合

目录

• 1.匿名结构体成员---继承
  • 例子1
  • 例子2
• 2.具名结构体成员--组合
  • 例子1
  • 例子2
• 3.参考

本文将介绍继承、组合这些复用概念在golang中是如何体现的。

在golang中，通过匿名结构体成员，可以访问匿名结构体中定义的的方法，就是所谓的实继承。

通过具名结构体成员，也可以访问该结构体中定义的方法，这就是所谓的组合。

1.匿名结构体成员---继承

例子1

结构体A1中包含匿名结构体A。

定义A1的变量a1，通过a1访问A的方法。

package main

import (
    "fmt"
)

type A struct {
    
}

func (t *A) Print(){
    fmt.Println("I am A.")
}

type A1 struct {
    A
}

func main() {
    a1 := A1{}
    a1.Print()
    
}

output:

I am A.

从输出结果可以看到，A1结构体的变量a1可以访问到A结构体中定义的Print()方法。也就是A1继承了A。

例子2

定义接口Aer，其中包含方法Print()。

接着定义A、A1。
A1中包含匿名结构体A。

定义测试函数test()，其参数是Aer接口类型。

package main

import (
    "fmt"
)


type Aer interface {
    Print()
}

type A struct {
    
}

func (t *A) Print(){
    fmt.Println("I am A.")
}

type A1 struct {
    A
}

func test(ai Aer) {
    ai.Print()
}

func main() {
    a1 := &A1{}

    test(a1)
    
}

output:

I am A.

通过输出可以看到，A1实现了Aer接口的Print()方法。
而这实际上是"继承"自A。

2.具名结构体成员--组合

例子1

结构体A1中包含结构体A类型的变量a。

定义结构体A的变量a，接着使用a定义结构体A1类型变量
a1。
最后通过a1访问a，再通过a访问A的方法。

package main

import (
    "fmt"
)

type A struct {
    
}

func (t *A) Print(){
    fmt.Println("I am A.")
}

type A1 struct {
    a A
}

func main() {
    a := A{}
    a1 := A1{a}
    a1.a.Print()
    
}

output:

I am A.

从输出结果可以看到，

例子2

定义接口Aer，其中包含方法Print()。

接着定义A、A1。
A1中包含结构体A类型变量a作为成员变量。

最后，测试A1是否实现了接口Aer。

package main

import (
    "fmt"
)

type Aer interface {
    Print()
}


type A struct {
    
}

func (t *A) Print(){
    fmt.Println("I am A.")
}

type A1 struct {
    a A
}

func main() {
    a := A{}
    a1 := A1{a}
    var i interface {} = a1

    ai, ok := i.(Aer)
    if ok {
        fmt.Println("a1 implement Aer")
        ai.Print()
    } else {
        fmt.Println("a1 not implement Aer")
    }
    
}

output:

a1 not implement Aer

通过结果可以看到，结构体A1并没有实现接口Aer。
也就是说，通过组合方式，没有"继承"相关的方法。

3.参考

Golang之继承，多重继承（struct）