Golang通脈之面向對象

2021 年 10 月 24 日
筆記
Go

面向對象的三大特徵：

封裝：隱藏對象的屬性和實現細節，僅對外提供公共訪問方式
繼承：使得子類具有父類的屬性和方法或者重新定義、追加屬性和方法等
多態：不同對象中同種行為的不同實現方式

Go並不是一個純面向對象的程式語言。在 Go 語言中可以使用結構體struct對屬性進行封裝，結構體就像是類的一種簡化形式。可以在結構體上添加捆綁數據和方法的行為，這些數據和方法與類類似

Go語言沒有「類」的概念，也不支援「類」的繼承等面向對象的概念。Go語言中通過結構體的內嵌再配合介面比面向對象具有更高的擴展性和靈活性。

結構體和方法

type Employee struct {  
    FirstName   string
    LastName    string
    TotalLeaves int
    LeavesTaken int
}

func (e Employee) LeavesRemaining() {  
    fmt.Printf("%s %s has %d leaves remaining", e.FirstName, e.LastName, (e.TotalLeaves - e.LeavesTaken))
}

func main() {  
    e := employee.Employee {
        FirstName: "Sam",
        LastName: "Adolf",
        TotalLeaves: 30,
        LeavesTaken: 20,
    }
    e.LeavesRemaining()
}

New()函數

Java語言中提供了構造方法創建並初始化對象，在Go語言中一般需要自己實現一個對外可見的New函數

func main() {  
    var e Employee
    e.LeavesRemaining()
}

運行結果：

has 0 leaves remaining

通過運行結果可以知道，使用Employee的零值創建的變數是不可用的。它沒有有效的名、姓，也沒有有效的保留細節。在其他的OOP語言中，比如java，這個問題可以通過使用構造函數來解決。使用參數化構造函數可以創建一個有效的對象。

go不支援構造函數。如果某個類型的零值不可用，則程式設計師的任務是不導出該類型以防止其他包的訪問，並提供一個名為NewT(parameters)的函數，該函數初始化類型T和所需的值。在go中，它是一個命名一個函數的約定，它創建了一個T類型的值給NewT(parameters)。這就像一個構造函數。如果包只定義了一個類型，那麼它的一個約定就是將這個函數命名為New(parameters)而不是NewT(parameters)。

首先修改employee結構體為非導出，並創建一個函數New()，它將創建一個新Employee：

type employee struct {  
    firstName   string
    lastName    string
    totalLeaves int
    leavesTaken int
}

func New(firstName string, lastName string, totalLeave int, leavesTaken int) employee {  
    e := employee {firstName, lastName, totalLeave, leavesTaken}
    return e
}

func (e employee) LeavesRemaining() {  
    fmt.Printf("%s %s has %d leaves remaining", e.firstName, e.lastName, (e.totalLeaves - e.leavesTaken))
}

在這裡做了一些重要的改變。已經將Employee struct的起始字母e設置為小寫。

由於employee是未導出的，所以不可能從其他包中創建類型employee的值。因此，提供了一個輸出的新函數。將所需的參數作為輸入並返回新創建的employee。

func main() {  
    e := employee.New("Sam", "Adolf", 30, 20)
    e.LeavesRemaining()
}

運行結果：

Sam Adolf has 10 leaves remaining

因此，雖然Go不支援類，但是結構體可以有效地使用，在使用構造函數的位置，使用New(parameters)的方法即可。

組合與繼承

在 Go 語言中沒有 extends 關鍵字，它使用在結構體中內嵌匿名類型的方法來實現繼承。在Go語言中稱之為組合(Composition)。組合的一般定義是「放在一起」。

舉一個部落格文章例子：每個部落格都有標題、內容和作者資訊。這可以用組合完美地表示出來。

嵌入結構體實現組合

可以通過將一個struct類型嵌入到另一個結構中實現：

/*
創建了一個author struct，它包含欄位名、lastName和bio。添加了一個方法fullName()，將作者作為接收者類型，這將返回作者的全名。
*/
type author struct {  
    firstName string
    lastName  string
    bio       string
}

func (a author) fullName() string {  
    return fmt.Sprintf("%s %s", a.firstName, a.lastName)
}
/*
post struct有欄位標題、內容。它還有一個嵌入式匿名欄位作者。這個欄位表示post struct是由author組成的。現在post struct可以訪問作者結構的所有欄位和方法。還在post struct中添加了details()方法
*/
type post struct {  
    title     string
    content   string
    author
}

func (p post) details() {  
    fmt.Println("Title: ", p.title)
    fmt.Println("Content: ", p.content)
    fmt.Println("Author: ", p.author.fullName())
    fmt.Println("Bio: ", p.author.bio)
}

func main() {  
    author1 := author{
        "Naveen",
        "Ramanathan",
        "Golang Enthusiast",
    }
    post1 := post{
        "Inheritance in Go",
        "Go supports composition instead of inheritance",
        author1,
    }
    post1.details()
}

運行結果：

Title:  Inheritance in Go  
Content:  Go supports composition instead of inheritance  
Author:  Naveen Ramanathan  
Bio:  Golang Enthusiast

嵌入結構體的切片

在以上程式的main函數下增加以下程式碼，並運行

type website struct {  
        []post
}
func (w website) contents() {  
    fmt.Println("Contents of Website\n")
    for _, v := range w.posts {
        v.details()
        fmt.Println()
    }
}

運行報錯：

syntax error: unexpected [, expecting field name or embedded type

這個錯誤指向structs []post的嵌入部分。原因是切片不能當做匿名欄位使用。需要一個欄位名

type website struct {  
        posts []post
}

修改完完整程式碼如下：

type author struct {  
    firstName string
    lastName  string
    bio       string
}

func (a author) fullName() string {  
    return fmt.Sprintf("%s %s", a.firstName, a.lastName)
}

type post struct {  
    title   string
    content string
    author
}
func (p post) details() {  
    fmt.Println("Title: ", p.title)
    fmt.Println("Content: ", p.content)
    fmt.Println("Author: ", p.fullName())
    fmt.Println("Bio: ", p.bio)
}

type website struct {  
 	posts []post
}
func (w website) contents() {  
    fmt.Println("Contents of Website\n")
    for _, v := range w.posts {
        v.details()
        fmt.Println()
    }
}
func main() {  
    author1 := author{
        "Naveen",
        "Ramanathan",
        "Golang Enthusiast",
    }
    post1 := post{
        "Inheritance in Go",
        "Go supports composition instead of inheritance",
        author1,
    }
    post2 := post{
        "Struct instead of Classes in Go",
        "Go does not support classes but methods can be added to structs",
        author1,
    }
    post3 := post{
        "Concurrency",
        "Go is a concurrent language and not a parallel one",
        author1,
    }
    w := website{
        posts: []post{post1, post2, post3},
    }
    w.contents()
}

運行結果：

Contents of Website

Title:  Inheritance in Go  
Content:  Go supports composition instead of inheritance  
Author:  Naveen Ramanathan  
Bio:  Golang Enthusiast

Title:  Struct instead of Classes in Go  
Content:  Go does not support classes but methods can be added to structs  
Author:  Naveen Ramanathan  
Bio:  Golang Enthusiast

Title:  Concurrency  
Content:  Go is a concurrent language and not a parallel one  
Author:  Naveen Ramanathan  
Bio:  Golang Enthusiast

介面與多態

Go中的多態性(Polymorphism)是在介面的幫助下實現的。介面可以在Go中隱式地實現。如果類型為介面中聲明的所有方法提供了定義，則該類型實現了這個介面。

任何定義介面所有方法的類型都被稱為隱式地實現該介面。

類型介面的變數可以保存實現介面的任何值。介面的這個屬性用於實現Go中的多態性。

定義一個正方形 Square 和一個長方形 Rectangle：

// 正方形
type Square struct {
    side float32
}

// 長方形
type Rectangle struct {
    length, width float32
}

計算這兩個幾何圖形的面積。但由於他們的面積計算方式不同，需要定義兩個不同的 Area() 方法。

於是，可以定義一個包含 Area() 方法的介面 Shaper，讓 Square 和 Rectangle 都實現這個介面里的 Area()：

// 介面 Shaper
type Shaper interface {
    Area() float32
}

// 計算正方形的面積
func (sq *Square) Area() float32 {
    return sq.side * sq.side
}

// 計算長方形的面積
func (r *Rectangle) Area() float32 {
    return r.length * r.width
}

在 main() 函數中調用 Area()：

func main() {
    r := &Rectangle{10, 2}
    q := &Square{10}

    // 創建一個 Shaper 類型的數組
    shapes := []Shaper{r, q}
    // 迭代數組上的每一個元素並調用 Area() 方法
    for n, _ := range shapes {
        fmt.Println("圖形數據: ", shapes[n])
        fmt.Println("它的面積是: ", shapes[n].Area())
    }
}

/*Output:
圖形數據:  &{10 2}
它的面積是:  20
圖形數據:  &{10}
它的面積是:  100
*/

由以上程式碼輸出結果可知：不同對象調用 Area() 方法產生了不同的結果，展現了多態的特徵。

總結

面向對象的三大特徵是：封裝、繼承和多態
Go 語言使用結構體對屬性進行封裝，結構體就像是類的一種簡化形式
在 Go 語言中，方法是作用在接收者（receiver）上的一個函數，接收者是某種類型的變數
名稱首字母的大小寫決定了該變數/常量/類型/介面/結構/函數……能否被外部包導入
無法被導入的欄位可以使用 getter 和 setter 的方式來訪問
Go 語言使用在結構體中內嵌匿名類型的方法來實現繼承
使用介面可以實現多態

Tags: Go