golang 接口嵌套實現復用的操作

Posted on by

大傢還是直接看代碼吧~

package main
import (
    "fmt"
)
func main() {
    start(NewB(C{}))
    start(NewB(D{}))
}
type A interface {
    what()
}
type B struct {
    A
}
type C struct {
}
func (b C) what() {
    fmt.Println("this is type C")
}
type D struct {
}
func (b D) what() {
    fmt.Println("this is type D")
}
func start(b B) {
    b.what()
}
func NewB(a A) B {
    return B{a}
}

補充：【玩轉Golang】通過組合嵌入實現代碼復用

應用開發中的一個常見情景，為瞭避免簡單重復，需要在基類中實現共用代碼，著同樣有助於後期維護。

如果在以往的支持類繼承的語言中，比如c++，Java，c#等，這很簡單！可是go不支持繼承，隻能mixin嵌入

且看下面的代碼：

type ManKind interface{
    Say(s string);   
    GetMouth()string
}
type Man struct{
   
}
func NewMan() ManKind{
    return &Man{};
}
func (this *Man)GetMouth()string{
    return "M0"
}
func (this *Man) Say(s string){
    fmt.Printf("\n Speak with mouth[%s] : \"%s\"",this.GetMouth(),s);
}
type StrongMan struct{
    Man
}
func NewStrongMan()ManKind{
    return &StrongMan{}
}
func (this*StrongMan)GetMouth()string{
    return "M1"
}
func main(){    
    NewMan().Say("good luck!")
    NewStrongMan().Say("good luck!")
}

如果支持繼承，很明顯應該輸出

Speak with mouth[M0] : “good luck!”

Speak with mouth[M1] : “good luck!”

但是在golang中隻能輸出：

Speak with mouth[M0] : “good luck!”

Speak with mouth[M0] : “good luck!”

StrongMan中調用Say(),此時可以將指針傳遞到內嵌類，隻是簡單的指向瞭Man的方法，在ManKind中調用GetMouth就是ManKind自己的GetMouth，和StrongMan沒有關系。

當然，我們可以在StrongMan中覆蓋Say方法

func (this *StrongMan)Say(s string){
    fmt.Printf("\n Speak with mouth[%s] : \"%s\"",this.GetMouth(),s);
}

此時，當然可以正確輸出，因為本來調用的就都是StrongMan自己的方法瞭，這又和我們的初衷相違背瞭。那麼這種情況怎麼實現呢？我的方法是，讓Man再臟一點兒，把需要的東西傳遞給組合進來的類。

給Man增加一個屬性mouth，增加一個SetMouth方法，修改一下GetMouth方法，StrongMan的GetMouth方法刪除掉，再修改一下NewStrongMan方法

最後的代碼如下：

package main
import(
    "fmt"
)
type ManKind interface{
    Say(s string);    
    SetMouth(m string)
    GetMouth()string
}
type Man struct{
    ManKind    
    mouth string
}
func NewMan() ManKind{
    return &Man{mouth:"M0"};
}
func (this *Man)GetMouth()string{
    return this.mouth;
}
func (this *Man)SetMouth(s string){
    this.mouth=s;
}
func (this *Man) Say(s string){
    fmt.Printf("\n Speak with mouth[%s] : \"%s\"",this.GetMouth(),s);
}
type StrongMan struct{
    Man
}
func NewStrongMan()ManKind{
    sm := &StrongMan{}
　　sm.SetMouth("M1");
　　return sm;
}
    
func main(){    
    NewMan().Say("good luck!")
    &NewStrongMan().Say("good luck!")
}

當然，如果你不願意用Get、Set方法，也可以直接輸出Man的Mouth屬性。

我總結的嵌入式編程要點：

1，被嵌入的類的方法，隻能訪問他自己的字段，包裝類即時聲明瞭同名字段也沒用。

2，包裝類可以覆蓋嵌入類的方法，但是嵌入類訪問不到，亦然訪問自己的方法。隻能在包裝類中連同調用方法一同實現。

3，包裝類覆蓋嵌入類字段後，亦然可以通過嵌入類的類名訪問嵌入類的字段。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：