上一节说过： public 和 private 是针对包一级的可见性，那么如果我们引入了一个其他同事或者第三方的包，有一个功能我们需要使用，但是他们并没有提供，这时候该怎么扩充呢？

使用组合

  如下，有一个第三方提供的加法方法：

package third_partyh

type TMath struct {
    I int
}

func (math *TMath) Add(tarMath TMath) {
    math.I += tarMath.I
}

  我们可以这样使用：

package main

import (
    "exercise/third_party"
    "fmt"
)

func main() {

    a := third_partyh.TMath{10}
    b := third_partyh.TMath{20}

    a.Add(b)
    fmt.Printf("Add：%d", a.I)

}

  后边需要一个 减法功能，但是没有提供，这时候可以使用组合方式来扩展原有结构体。

type MyMath struct {
    TMath *third_partyh.TMath
}

func (math *MyMath) sub(myMath MyMath) {
    if math.TMath == nil || myMath.TMath == nil {
        fmt.Println("TMath is nil")
    }
    math.TMath.I -= myMath.TMath.I
}

  把第三方的实例引用过来，进行扩展。调用：

func main() {

    a := third_partyh.TMath{10}
    b := third_partyh.TMath{20}

    myMathA := MyMath{&a}
    myMathB := MyMath{&b}

    myMathA.sub(myMathB)
    fmt.Printf("Sub：%d", myMathA.TMath.I)

}

定义别名

  这里给 []int，定义别名，自定义一个简单的队列作为样例：

  类型为 slice of int 的队列

package queue

// A FIFO queue.
type Queue []int

// Pushes the element into the queue.
//      e.g. q.Push(123)
func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

// Pops element from head.
func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

// Returns if the queue is empty or not.
func (q *Queue) IsEmpty() bool {
    return len(*q) == 0
}

  调用

func main() {
    q := Queue{1}
    q.Push(2)
    q.Push(3)
    fmt.Println(q.Pop())
    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())

    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())
}