go語言的面向對象模型

      Go語言的面向對象模型與主流OO語言差別很大，本文經過對比Go與C++的三個差別來介紹Go的面向對象模型及其設計思想。

 

一：可見性控制粒度是包

Go用首寫字母的大小寫來控制類、類成員、函數的可見性, 可見性控制的粒度是包。下面是Go和C++對Person的實現：

Go：

type Person struct {

    name string  //首字母小寫，包外不可見

    Age  int    //首字母大寫，包外可見

}

 

C++：

struct Person{

    private: std::string name;  //類外不可見

    public： int age;        //類外可見

};

 

要理解Go的作法，首先咱們要問爲何要控制可見性？是爲了隱藏實現細節。那麼爲何要隱藏實現細節？是爲了儘量地減小對客戶代碼的影響。說究竟是爲了讓客戶能更容易地重用代碼，因此可見性控制粒度應該與重用粒度相一致。Go認爲重用粒度是包，所以只控制包的可見性。固然從完美角度看，這種作法會增長包內類之間的耦合，可是它也避免了新增友元特性以支持包內類之間的更密切的關聯，這使得語言特性保持簡潔, 而簡潔正是Go語言的追求目標。

 

二：沒有繼承，只有組合

Go沒有繼承，只有組合。類功能複用能夠經過匿名組合實現。下面是Go和C++對Teacher的實現：

Go:

type Teacher struct{

    Person

    school string

}

 

C++:

struct Teacher:Person{

    private: std::string school;

};

繼承曾經被認爲是OO最重要的特性。隨着OO實踐的深刻，社區才逐漸認識到繼承的弊端。實際上，當咱們深刻研究繼承，就會發現它同時幹了兩件事情：

1、複用實現。

2、IS-A語義。

對於第一點，使用組合遠比繼承要更優秀，由於組合是黑盒複用，繼承是白盒複用，複雜的繼承樹大大加劇了程序員的心智負擔。

對於第二點，IS-A語義的威力只有當咱們基於接口進行編程（把IS-A理解爲接口）時，才能充分地發揮。可是接口本質上是一種抽象，而這種抽象依賴於client，也就是說若是用繼承，咱們被迫要在實現類的時候對client的使用作適當地預測，不然就很難實現ISP，DIP這些設計原則。

既然繼承作了兩件事，並且作的都很差，Go就把繼承拆分爲兩個更加單一的特性：匿名組合、Interface。經過匿名組合來複用實現，經過Interface支持基於接口的編程。

 

三：類型安全的鴨子類型

在第二節咱們提到Go沒有繼承，Go也沒有虛函數，它經過Interface實現IS-A語義來支持基於接口的編程，下面用Go和C++分別實現鴨子、野鴨子、打飛鳥的示例：

Go：

type Duck struct {//鴨子

       location Location //鴨子當前位置

}

 

func (duck *Duck) GetLocation() Location {//獲取鴨子當前所處位置

       return duck.location

}

 

type WildDuck struct {//野鴨子

       Duck

}

 

func (wildDuck *WildDuck) Fly() {//飛走

}

 

type Flyer interface {//飛鳥

       Fly()

       GetLocation() Location

}

 

func ShotFlyer(location Location, flyer Flyer) {//打飛鳥

       if location != flyer.GetLocation() { //沒打中飛走了

              flyer.Fly()

       }

}

 

func TestShotFlyer() {

       flyer := new(WildDuck)

       ShotFlyer(Location{1, 2, 3}, flyer)

}

 

C++：

struct Flyer{//飛鳥

    virtual void Fly()=0;

    virtual const Location& GetLocation()=0;

};

 

struct Duck{//鴨子

    void const Location& GetDuckLocation()

   

    private: Location location;

};

 

struct WildDuck:Duck, Flyer{//野鴨子

    private: virtual void Fly(){}

    private: virtual const Location& GetLocation(){return GetDuckLocation();}

};

 

void ShotFlyer(const Location& location, Flyer &flyer) {//打野鴨子

       if (location != flyer.GetLocation()) {//沒打中飛走了

              flyer.Fly()

       }

}

 

void TestShotFlyer() {

       Flyer* flyer := new WildDuck()

       ShotFlyer(Location(1,2,3), flyer)

}

咱們先來看Go的實現，WildDuck經過匿名組合Duck來複用Duck的GetLocation方法，爲了能讓ShotFlyer基於Flyer接口編程，WildDuck並不須要繼承Flyer，只要實現了Flyer的全部方法，就能讓編譯器認爲它就是Flyer，Flyer與WildDuck之間是鬆耦合的關係。

再看C++實現，WildDuck須要繼承Flyer接口讓編譯器認爲它就是Flyer，可是WildDuck不能直接複用Duck來實現Flyer的GetLocation方法，由於在編譯器看來Duck不是Flyer，那麼它就不能實現Flyer的方法，因此WildDuck只能本身實現虛函數GetLocation，經過GetLocation調用Duck的GetDuckLocation來複用Duck的獲取當前位置功能。

從上面比較能夠看出，Go的實現比C++的更加優雅，這種優雅是因爲接口與實現的鬆耦合帶來的。鬆耦合可讓接口與實現相對獨立地演進；能夠各自經過組合實現功能複用；也能夠在實現具體類以後，無需修改具體類就能新增抽象接口以應對不一樣的應用場景（這個正是人解決問題的經常使用方式，先具體再抽象）。