Go 面向對象
Go是一個完全面向對象的語言。例如，它允許基于我們定義的類型的方法，而沒有像其他語言一樣的裝箱/拆箱操作。
Go沒有使用classes，但提供很多相似的功能：
·通過嵌入實現的自動消息委托
·通過接口實現多臺
·通過exports實現的命名空間
Go語言中沒有繼承。忘記is-a的關系，而是就組合而言的面向對象設計。
| “使用經典的繼承始終是可選的；每個問題都可以通過其他方法得到解決” - Sandi Metz |
通過例子說明組合
最近閱讀了一篇Ruby的面向對象編程實踐, 我決定使用Go語言翻譯這個例子。
Chapter 6說明了一個簡單的問題。維修工需要知道自行車出行需要帶上的備件，決定于哪一輛自行車已經被租出去。問題可以通過經典的繼承來解決，山地車和公路自行車是自行車基類的一個特殊化例子。Chapter 8使用組合改寫了同一個例子。我很高興這個例子翻譯成Go。讓我們看看。
Packages(包)
- package main
- import "fmt"
包提供了命名空間概念. main() 函數是這個包的入口函數. fmt包提供格式化功能
Types(類型)
- type Part struct {
- Name string
- Description string
- NeedsSpare bool
- }
我們定義了一個新的類型名為Part, 非常像c的結構體
- type Parts []Part
Parts類型是包含Part類型的數組切片, Slice可以理解為動態增長的數組, 在Go中是很常見的.
我們可以在任何類型上聲明方法, 所以我們不需要要再去封裝 []Part, 這意味著 Parts 會擁有slice的所有行為, 再加上我們自己定義的行為方法.
方法
- func (parts Parts) Spares() (spares Parts) {
- for _, part := range parts {
- if part.NeedsSpare {
- spares = append(spares, part)
- }
- }
- return spares
- }
Go中定義方法就像一個函數，除了它有一個顯式的接收者，緊接著func之后定義。這個函數利用命名返回變量，并為我們初始化備件。
方法的主體十分簡單。我們重復parts，忽略索引的位置(_)，過濾parts后返回。append builtin 需要分配和返回一個大的切片，因為我們并沒有預先分配好它的容量。
這段代碼沒有ruby代碼來得優雅。在Go語言中有過濾函數，但它并非是builtin.
內嵌
- type Bicycle struct {
- Size string
- Parts
- }
自行車由Size和Parts組成。沒有給Parts指定一個名稱，我們是要保證實現 內嵌。這樣可以提供自動的委托，不需特殊的聲明，例如bike.Spares()和bike.Parts.Spares()是等同的。
如果我們向Bicycle增加一個Spares()方法，它會得到優先權，但是我們仍然引用嵌入的Parts.Spares()。這跟繼承十分相似，但是內嵌并不提供多態。Parts的方法的接收者通常是Parts類型，甚至是通過Bicycle委托的。
與繼承一起使用的模式，就像模板方法模式，并不適合于內嵌。就組合和委托而言去考慮會更好，就如我們這個例子一樣。
Composite Literals(復合語義)
- var (
- RoadBikeParts = Parts{
- {"chain", "10-speed", true},
- {"tire_size", "23", true},
- {"tape_color", "red", true},
- }
- MountainBikeParts = Parts{
- {"chain", "10-speed", true},
- {"tire_size", "2.1", true},
- {"front_shock", "Manitou", false},
- {"rear_shock", "Fox", true},
- }
- RecumbentBikeParts = Parts{
- {"chain", "9-speed", true},
- {"tire_size", "28", true},
- {"flag", "tall and orange", true},
- }
- )
Go提供優美的語法，來初始化對象，叫做 composite literals。使用像數組初始化一樣的語法，來初始化一個結構，使得我們不再需要ruby例子中的Parts工廠。
- func main() {
- roadBike := Bicycle{Size: "L", Parts: RoadBikeParts}
- mountainBike := Bicycle{Size: "L", Parts: MountainBikeParts}
- recumbentBike := Bicycle{Size: "L", Parts: RecumbentBikeParts}
Composite literals（復合語義）同樣可以用于字段：值的語法，所有的字段都是可選的。
簡短的定義操作符(:=)通過Bicycle類型，使用類型推論來初始化roadBike，和其他。
輸出
- fmt.Println(roadBike.Spares())
- fmt.Println(mountainBike.Spares())
- fmt.Println(recumbentBike.Spares())
我們將以默認格式打印 Spares 的調用結果：
- [{chain 10-speed true} {tire_size 23 true} {tape_color red true}]
- [{chain 10-speed true} {tire_size 2.1 true} {rear_shock Fox true}]
- [{chain 9-speed true} {tire_size 28 true} {flag tall and orange true}]
組合 Parts
- comboParts := Parts{}
- comboParts = append(comboParts, mountainBike.Parts...)
- comboParts = append(comboParts, roadBike.Parts...)
- comboParts = append(comboParts, recumbentBike.Parts...)
- fmt.Println(len(comboParts), comboParts[9:])
- fmt.Println(comboParts.Spares())
- }
Parts 的行為類似于 slice。按照長度獲取切片，或者將數個切片結合。Ruby 中的類似解決方案就數組的子類,但是當兩個 Parts 連接在一起時，Ruby 將會“錯置” spares 方法。
| “……在一個完美的面向對象的語言，這種解決方案是完全正確的。不幸的是，Ruby語言并沒有完美的實現……” —— Sandi Metz |
在 Ruby 中有一個那看的解決方法，使用 Enumerable、forwardable，以及 def_delegators。 Go有沒有這樣的缺陷。 []Part 正是我們所需要的，且更為簡潔（更新：Ruby 的 SimpleDelegator 看上去好了一點）。
接口 Interfaces
Go的多態性由接口提供。不像JAVA和C#，它們是隱含實現的，所以接口可以為不屬于我們的代碼定義。
和動態類型比較，接口是在它們聲明過程中靜態檢查和說明的，而不是通過寫一系列響應（respond_to）測試完成的。
| “不可能不知不覺的或者偶然的創建一個抽象；在靜態類型語言中定義的接口總是有傾向性的。” - Sandi Metz |
給個簡單的例子，假設我們不需要打印Part的NeedsSpare標記。我們可以寫這樣的字符串方法：
- func (part Part) String() string {
- return fmt.Sprintf("%s: %s", part.Name, part.Description)
- }
然后對上述Print的調用將會輸出這樣的替代結果：
- [chain: 10-speed tire_size: 23 tape_color: red]
- [chain: 10-speed tire_size: 2.1 rear_shock: Fox]
- [chain: 9-speed tire_size: 28 flag: tall and orange]
這個機理是因為我們實現了fmt包會用到的Stringer接口。它是這么定義的：
- type Stringer interface {
- String() string
- }
接口類型在同一個地方可以用作其它類型。變量與參數可以攜帶一個Stringer，可以是任何實現String() string方法簽名的接口。
Exports 導出
Go 使用包來管理命名空間, 要使某個符號對其他包（package ）可見（即可以訪問），需要將該符號定義為以大寫字母開頭, 當然,如果以小寫字母開關,那就是私有的.包外不可見.
- type Part struct {
- name string
- description string
- needsSpare bool
- }
為了對Part類型應用統一的訪問原則(uniform access principle), 我們可以改變Part類型的定義并提供setter/getter 方法,就像這樣:
- func (part Part) Name() string {
- return part.name
- }
- func (part *Part) SetName(name string) {
- part.name = name
- }
這樣可以很容易的確定哪些是public API, 哪些是私有的屬性和方法, 只要通過字母的大小寫.(例如(part.Name()vs.part.name)
注意 我們不必要對 getters 加前Get, (例如.GetName),Getter不是必需,特別是對于字符串,當我們有需要時,我們可以使用滿足Stringer 類型接口的自定義的類型去改變Name 字段。
找到一些私有性
私有命名（小寫字母）可以從同一個包的任何地方訪問到，即使是包含了跨越多個文件的多個結構。如果你覺得這令人不安，包也可以像你希望的那么小。
可能的情況下用（更穩固的）公共API是一個好的實踐，即使是來自經典語言的同樣的類中。這需要一些約定，當然這些約定可以應用在GO中。
最大的好處
組合，內嵌和接口提供了Go語言中面向對象設計的強大工具。繼承概念的思想真的不起什么作用。相信我，我嘗試了。
習慣Go需要思維的改變，當觸及到Go對象模型的力量時，我非常高興的吃驚于Go代碼的簡單和簡潔。
原文鏈接：http://www.oschina.net/translate/go-object-oriented-design
