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

梦里梦外; 2022-12-19 13:15 255阅读 0赞

### 目录 ###

*  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）][Golang_struct]

[Golang_struct]: https://studygolang.com/articles/12175