計劃寫一系列基于golang語言面向物件和設計模式的文章，此系列將結合golang代碼實作介紹一些常用的設計模式，設計模式主要包括Gang of Four的經典書籍里面的三大型別包括創建型（Creational）行為型（Behavioral）和結構型（Structural），本篇為開篇第一篇，首先介紹一下面向物件和go語言中面向物件的方法，

面向物件

面向物件（OOP）的編程方法是當前高級語言編程比如C++, Java，python等常用的編程思想，面向物件網上資料很多這里僅作簡單的介紹，面向物件編程的核心思想就是將代碼分成許多小的物件（object），每個物件都有自己的屬性和行為，屬性描述了物件當前的狀態，行為描述了物件可以做什么事情，行為通常被抽象成一個函式供呼叫，在OOP中這個函式也被稱為方法（method），

類(class)是具有相同屬性和方法的一組物件的集合,它可以用來創建并初始化物件，在設計類的時候一個關鍵的指導原則就是封裝，封裝簡單來說就是將代碼及其處理的資料系結在一起，形成一個獨立單位，對外實作完整功能，并盡可能隱藏物件的內部細節，在代碼實作程序中我們并不能將所有的實作都封裝在一個大類里面，這樣寫出的代碼是幾乎無法維護的，而應該是將其拆成許多可維護的小類，

在有些時候我們會發現一些有相同的屬性和方法的類或物件，例如我們在開發一個web后端的時候經常會用到快取，快取的種類很多例如 Redis,Memcahe等，而對快取的操作基本就是固定的GET SET RPUSH等，因此可以創建一個Cache的父類其他的子類繼承這個父類即可，這就是面向物件的繼承(Inheritance)，

然而繼承在使用的時候往往會遇到一些問題，繼承使得類之間的層級關系變得復雜，這樣超級父類(Superclass)會變得很脆弱，微小的改動可能會帶來子類上的一些問題，為了解決這個問題就引入了組合（Composition )的概念，現在大部分人在編程的時候一般都秉承Composition Over Inheritance的基本原則，組合使用的方式

1.父類定義介面，子類實作這些介面

2.Method的復用采用呼叫的方式而不是繼承

Golang 中的面向物件的方法

上面羅嗦了這么多接下來是golang中面向物件的代碼實作

結構體

golang中是沒有類的概念的，而是使用結構體，如下是定義了一個Cluster的結構體（注意代碼摘自一些專案僅為解釋概念使用并不能直接運行），

type cluster struct {
	remote   pb.ClusterClient
	callOpts []grpc.CallOption
}

通過結構體可以實體化一個物件

api := cluster{remote: RetryClusterClient(c)}

這樣我們就可以訪問物件的變數了

fmt.Println(api.remote)

Go 語言也提供了指標的訪問方法，同樣也是用點來訪問變數，這點跟C語言的指標是不一樣的如下函式

func NewCluster(c *Client) Cluster {
	api := &cluster{remote: RetryClusterClient(c)}
	if c != nil {
		api.callOpts = c.callOpts
	}
	return api
}

結構體Method通過func來定義，結構體的方法與普通函式不一樣在func與函式名之間需要有一個receiver，如下面的例子

func (c *cluster) memberAdd(ctx context.Context, peerAddrs []string, isLearner bool) (*MemberAddResponse, error) {
	// fail-fast before panic in rafthttp
	if _, err := types.NewURLs(peerAddrs); err != nil {
		return nil, err
	}

上面的例子中*cluster 是一個receiver

當然也可以使用非指標型別的receiver，指標型別的receiver提供了Pass-By-Reference 機制，而非指標則是Pass-By-Value，總體來說到底是使用指標型別還是非指標型別遵循以下原則

1. 如果想改變receiver的屬性值就使用指標
2. 如果receiver很大使用deepcopy的時候會占用很大的資源就使用指標

可見性

go語言中沒有public 和private，但是go語言提供了定義公有變數和私有變數的方法：變數首字母法，如果一個變數的首字母是大寫則為public 反之則為private，同樣首字母法也適用與method

介面

介面是go語言里面非常重要的一個用法，也是實作面向物件編程的關鍵，go語言中采用的是隱式介面實作，如果一個物件實作了一個介面的所有的method那么這個物件就實作了這個介面，通過介面go語言實作了多型，

如下我們定義一個介面Cluster 里面包含了六個method

type Cluster interface {
	MemberList(ctx context.Context) (*MemberListResponse, error)
	MemberAdd(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
	MemberAddAsLearner(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
	MemberRemove(ctx context.Context, id uint64) (*MemberRemoveResponse, error)
	MemberUpdate(ctx context.Context, id uint64, peerAddrs []string) (*MemberUpdateResponse, error)
	MemberPromote(ctx context.Context, id uint64) (*MemberPromoteResponse, error)
}

我們的實際應用中會有HttpCluster和GrpcCluster兩種實作，因此我們需要定義兩個struct然后分別實作介面中的六個Method即可

GrpcCluster:

// 定義結構體
type GrpcCluster struct {
	remote   pb.ClusterClient
	callOpts []grpc.CallOption
}
// 實作介面
func (c *GrpcCluster) MemberAdd(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
 {

    res,err := memberAdd()
    return res,err
 }
func (c *GrpcCluster) MemberList(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
 {

    res,err := memberlist()
    return res,err
 }

func (c *GrpcCluster) MemberAddAsLearner(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
 {

    res,err := addaslearner()
    return res,err
 }
func (c *GrpcCluster) MemberRemove(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
 {

    res,err := remove()
    return res,err
 }
func (c *GrpcCluster) MemberUpdate(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
 {

    res,err := update()
    return res,err
 }
func (c *GrpcCluster) MemberPromote(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
 {

    res,err := promote()
    return res,err
 }

HttpCluster 同樣定義結構體并實作方法即可，實作方法類似此處省略了偽代碼，

定義好之后就可以在代碼中使用了如下片段為如何使用

var clt Cluster
service_type := getserviceType()
switch service_type {
case "http":
	clt = HttpCluster{}
case "grpc"
	clt = GrpcCluster{}
	
}
exeute(clt)

繼承和組合

Goglang中沒有extends關鍵字，繼承是通過結構體嵌套(Struct embeding)實作的

如果一個struct嵌套了另一個匿名結構體，那么這個結構可以直接訪問匿名結構體的方法，從而實作繼承

如果一個struct嵌套了另一個【有名】的結構體，那么這個模式叫做組合
如下兩個結構體

type SetSlackServiceOptions struct {
    WebHook  *string `url:"webhook,omitempty" json:"webhook,omitempty" `
    Username *string `url:"username,omitempty" json:"username,omitempty" `
    Channel  *string `url:"channel,omitempty" json:"channel,omitempty"`
}
type ExtendedStruct struct {
  SetSlackServiceOptions
  MoreValues []string
}

結構體ExtendedStruct中隱式宣告了SetSlackServiceOptions因此ExtendedStruct就自動擁有了SetSlackServiceOptions所有的方法因此達到了繼承的功能，

另外介面也可以組合使用

type Reader interface {
    Read(p []byte) (n int, err error)
}
 
type Writer interface {
    Write(p []byte) (n int, err error)
}
 
type ReadWriter interface {
    Reader
    Writer
}

其實很簡單, 就是把Reader, Writer嵌入到ReadWriter中, 這樣ReadWriter就擁有了Reader和Writer的方法，

總結

這篇作為開篇主要介紹了面向物件的編程方式以及go語言中面向物件的一些特殊方式，下一篇將開始介紹設計模式，敬請期待