前言

面向物件的含義引入了物件（object)、類（class）、繼承（inheritance）、子類（subclass）、虛方法（virtual method）、協程（coroutine）等概念。面向物件引入顛覆性的思想——將資料和邏輯完全分離。大部分程式設計師通過程式語言進行軟體開發都遵循著將資料和邏輯完全分離的原則。

由於面向物件沒有標準的定義，為了討論的方便，接下來我們將提供一個標準的定義。

面向物件系統將資料和程式碼通過“物件”整合到一起，而不是將程式看成由分離的資料和程式碼組成。物件是資料型別的抽象，它有狀態（資料）和行為（程式碼）

面向物件包括封裝、繼承、多型、虛派生等特性，接下來我們將看看go語言是怎樣處理物件、多型、繼承

go中的物件-封裝

go語言中沒有物件(object)這個關鍵詞。物件（object）僅僅是一個單詞，重要的是它所表示的封裝資料含義。儘管go中沒有object這種型別，但是go中的struct有著跟object相同的特性。而在go中，採用了一種算是規定的方法：使用大小寫來確定，大寫是包外可見的，小寫的struct或函式只能在包內使用。

struct是一種包含了命名域和方法的型別

讓我們從一個例子中來理解它：

type rect struct {
    width int
    height int
}

func (r *rect) area() int {
    return r.width * r.height
}

func main() {
    r := rect{width: 10, height: 5}
    fmt.Println("area: ", r.area())
}
 

(1) 程式碼的第一塊定義了一個叫做rect的struct型別，該struct含有兩個int型別的域；

(2) 接下來定義了一個繫結在rect struct型別上的area方法。嚴格來說，area方法是繫結在指向rectct struct的指標上。如果方法繫結在rect type而非指標上，則在呼叫方法的時候需要使用該型別的值來呼叫，即使該值是空值，本例的空值實際是一個nil值；

(3) 程式碼的最後一塊是main函式，main函式第一行建立了一個rect型別的值,當然也有其他的方法來建立一個型別的值，這裡給出的是一個地道的方法。main函式的最後一行是列印作用在r值上的area方法的返回結果。

通過上面的描述，可以看出這很像物件的行為，我們可以建立一個結構化的資料型別，然後定義方法和這些資料進行互動

繼承和多型

定義物件間的關係的方法有如下幾種，它們之間都有一些差別，但目的都是一樣的：複用程式碼。
單繼承（Inheritance） 多繼承（Multiple Inheritance） 多型（Subtyping/Polymorphism）物件組合（Object composition）
繼承：一個物件基於另外一個物件，使用其實現。有兩種不同的繼承實現：單繼承和多繼承。它們的不同在於物件是繼承自一個物件還是多個物件。單繼承關係是一棵樹，而多繼承關係是一個格狀結構。單繼承語言包括PHP、C#、Java、Ruby等，多繼承語言包括Perl、Python、C++等

多型

多型是is-a的關係，繼承是實現的複用。多型定義了兩個物件的語義關係，繼承定義兩個物件的語法關係。

物件組合

物件組合是一個物件包含了其他物件，而非繼承，它是has-a的關係，而非is-a。

go語言的繼承

go有意得被設計為沒有繼承語法。但這並不意味go中的物件（struct value)之間沒有關係，只不過go的作者選擇了另外一種機制來暗含這種特性。實際上go的這種設計是一種非常好的解決方法，它解決了圍繞著繼承的數十年的老問題和爭論。

go語言中的多型和組合(最好不要繼承)

type Person struct {
   Name string
   Address Address    //匿名欄位
}

type Address struct {
   Number string
   Street string
   City   string
   State  string
   Zip    string
}

func (p *Person) Talk() {
    fmt.Println("Hi, my name is", p.Name)
}

func (p *Person) Location() {
    fmt.Println("I’m at", p.Address.Number, p.Address.Street, p.Address.City, p.Address.State, p.Address.Zip)
}

func main() {
    p := Person{
        Name: "Steve",
        Address: Address{
            Number: "13",
            Street: "Main",
            City:   "Gotham",
            State:  "NY",
            Zip:    "01313",
        },
    }

    p.Talk()
    p.Location()
}

程式執行結果：

上面的例子需要注意的是， Address仍然是一個不同的物件，只不過存在於Person中。

go中的偽多型

我們通過擴充套件上面的例子來說明go中的偽多型。注意這裡“偽”字說明實際上go是沒有多型的概念的，只不過偽多型表現得像多型一樣。下面的例子中，Person可以說話(Talk），一個Citizen也同時是一個Person，因此他也能說話(Talk）。在上面的例子中加入如下內容，完整程式碼見：http://play.golang.org/p/eCEpLkQPR3。

type Citizen struct {
   Country string
   Person
}

func (c *Citizen) Nationality() {
    fmt.Println(c.Name, "is a citizen of", c.Country)
}

func main() {
    c := Citizen{}
    c.Name = "Steve"
    c.Country = "America"
    c.Talk()
    c.Nationality()
}

上面的例子通過引入匿名域（Person）實現了is-a關係。Person是Citizen的一個匿名域（anonymous field），匿名域只給出了物件型別，而不給出型別的名字。通過匿名域，Citizen可以訪問Person中的所有屬性（域）和方法。程式執行結果如下所示：

匿名域方法提升

上述例子，Citizen可以和Person執行一樣的Talk()方法。但如果想要Citizen的Talk()表現出不同的行為該怎麼做呢？我們只需要在Citizen上定義方法Talk()即可。當呼叫c.Talk()的時候，呼叫的則是Citizen的Talk()方法而非Person的Talk()方法，http://play.golang.org/p/jafbVPv5H9。

func (c *Citizen) Talk() {
    fmt.Println("Hello, my name is", c.Name, "and I'm from", c.Country)
}

程式執行結果：

為何匿名域不是合適的多型實現

有兩個原因：

1. 匿名域仍然能被訪問，就好像它們是被嵌入的物件一樣。

這並不是一件壞事，多繼承存在的一個問題就是當多個父類具有相同的方法的時候，會產生歧義。然而go語言可以通過訪問跟匿名型別同名的屬性來訪問嵌入的匿名物件。實際上當使用匿名域的時候，go會建立一個跟匿名型別同名的物件。上面的例子中，修改main方法如下，我們能很清楚得看出這一點：

func main() {
//    c := Citizen{}
    c.Name = "Steve"
    c.Country = "America"
    c.Talk()         // <- Notice both are accessible
    c.Person.Talk()  // <- Notice both are accessible
    c.Nationality()
}

package main

type A struct{
}

type B struct {
    A  //B is-a A
}

func save(A) {
    //do something
}

func main() {
    b := B
    save(&b);  //OOOPS! b IS NOT A
}

程式執行報錯：

prog.go:17: cannot use b (type *B) as type A in function argument
[process exited with non-zero status]

go中的真正的多型實現

正如我們上面提到的，多型是一種is-a的關係。在go語言中，每種型別(type)都是不同的，一種型別不能完全等同於另外一種型別，但它們可以繫結到同一個介面（interface）上。介面能用於函式（方法）的輸入輸出中，因而可以在型別之間建立起is-a的關係。

go語言定義一個介面並不是使用using關鍵字，而是通過在物件上定義方法來實現。在Effective Go中指出，這種關係就像“如果某個東西能做這件事，那麼就把它應用到這裡”（不管黑貓白貓，只要能抓到老鼠，我就養這隻貓）。這一點很重要，因為這允許一個定義在package外的型別也能實現該介面。

我們接著上面的例子，增加一個新函式SpeakTo，然後修改main函式，將該方法應用到Citizen和Person上,http://play.golang.org/p/lvEjaMQ25D。

func SpeakTo(p *Person) {
    p.Talk()
}

func main() {
    p := Person{Name: "Dave"}
    c := Citizen{Person: Person{Name: "Steve"}, Country: "America"}

    SpeakTo(&p)
    SpeakTo(&c)
}

程式執行結果出錯：型別不一致，因此可藉助 介面來實現。

Running it will result in
prog.go:48: cannot use c (type *Citizen) as type *Person in function argument
[process exited with non-zero status]

跟預期的結果一樣，編譯失敗。Citizen並不是Person型別，儘管他們擁有同樣的屬性。然而我們定義一個介面（interface）Human，然後將這個介面作為SpeakTo函式的輸入引數，上面的例子就可以正常運行了，http://play.golang.org/p/ifcP2mAOnf。

type Human interface {
    Talk()
}

func SpeakTo(h Human) {
    h.Talk()
}

func main() {
    p := Person{Name: "Dave"}
    c := Citizen{Person: Person{Name: "Steve"}, Country: "America"}

    SpeakTo(&p)
    SpeakTo(&c)
}

Hi, my name is Dave
Hi, my name is Steve

關於go語言中的多型，有如下兩點需要注意。

1. 可以把匿名域繫結到一個介面，也能繫結到多個介面。介面和匿名域一起使用，可以起到和多型同樣的效果。

2. go提供了多型的能力。介面的使用能使得實現了該介面方法的不同物件都能作為  函式的輸入引數  ，甚至作為 返回結果 ，但它們仍然保持了它們自己的型別。這點從上面的例子能看出來，我們不能直接在初始化Citizen物件的時候設定Name值，因為Name不是Citizen的屬性，而是Person的屬性，因而不能再初始化Citizen的時候設定Name值。

go，一個沒有object和inheritance的面向物件的語言

如上所述，面向物件的基本概念在go中被很好的實現了，雖然術語上存在差別。

(1) go把struct作為資料和邏輯的結合。

(2) 通過組合(composition)，has-a關係來最小化程式碼重用，並且避免了繼承的缺陷。

(3) go使用介面(interface)來建立型別（type）之間的is-a關係。

討論

深入閱讀