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++分别實作鴨子、野鴨子、打飛鳥的示例：

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)

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()) {//沒打中飛走了

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++的更加優雅，這種優雅是由于接口與實作的松耦合帶來的。松耦合可以讓接口與實作相對獨立地演進；可以各自通過組合實作功能複用；也可以在實作具體類之後，無需修改具體類就能新增抽象接口以應對不同的應用場景（這個正是人解決問題的常用方式，先具體再抽象）。