Go语言——没有对象的面向对象编程

本文译自Steve Francia在OSCON 2014的一个PPT，原做请前往：https://spf13.com/presentation/go-for-object-oriented-programmers/

---

对我来讲，最吸引个人不是Go拥有的特征，而是那些被故意遗漏的特征。 —— txxxxd

为何你要创造一种从理论上来讲，并不使人兴奋的语言？
由于它很是有用。 —— Rob Pike

Go中的“对象”

要探讨Go语言中的对象，咱们先搞清楚一个问题：

Go语言有对象吗？

从语法上来讲，

• Go中没有类（Classes）
• Go中没有“对象”（Objects）

到底什么是对象？

对象是一种抽象的数据类型，拥有状态（数据）和行为（代码）。 —— Steve Francia

在Go语言中，咱们这样声明一个类型：

类型声明（Struct）

type Rect struct {
    width  int
    height int
}

而后咱们能够给这个Struct声明一个方法

func (r *Rect) Area() int {
    return r.width * r.height
}

用起来就像这样

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

咱们不光能够声明结构体类型，咱们能够声明任何类型。好比一个切片：

类型声明（Slice）

type Rects []*Rect

一样也能够给这个类型声明一个方法

func (rs Rects) Area() int {
    var a int
    for _, r := range rs {
        a += r.Area()
    }
    return a
}

用起来

func main() {
    r := &Rect{width: 10, height: 5}
    x := &Rect{width: 7, height: 10}
    rs := Rects{r, x}
    fmt.Println("r's area: ", r.Area())
    fmt.Println("x's area: ", x.Area())
    fmt.Println("total area: ", rs.Area())
}

https://play.golang.org/p/G1OWXPGvc3

咱们甚至能够声明一个函数类型

类型声明（Func）

type Foo func() int

一样的，给这个（函数）类型声明一个方法

func (f Foo) Add(x int) int {
    return f() + x
}

而后用起来

func main() {
    var x Foo

    x = func() int { return 1 }

    fmt.Println(x())
    fmt.Println(x.Add(3))
}

https://play.golang.org/p/YGrdCG3SlI

经过上边的例子，这样看来，其实

Go有“对象”

那么咱们来看看

“面向对象”的Go

若是一种语言包含对象的基本功能：标识、属性和特性，则一般认为它是基于对象的。
若是一种语言是基于对象的，而且具备多态性和继承性，那么它被认为是面向对象的。 —— Wikipedia

第一条，咱们在上边的例子看到了，go中的type declaration其实知足了Go语言是基于对象的。那么，

Go是基于对象的，它是面向对象的吗？

咱们来看看关于第二条，继承性和多态性

继承

• 提供对象的复用
• 类是按层级建立的
• 继承容许一个类中的结构和方法向下传递这种层级

Go中实现继承的方式

• Go明确地避免了继承
• Go严格地遵循了符合继承原则的组合方式
• Go中经过嵌入类型来实现组合

组合

• 提供对象的复用
• 经过包含其余的对象来声明一个对象
• 组合使一个类中的结构和方法被拉进其余类中

继承把“知识”向下传递，组合把“知识”向上拉升 —— Steve Francia

嵌入类型

type Person struct {
    Name string
    Address
}

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

给被嵌入的类型声明一个方法

func (a *Address) String() string {
    return a.Number + " " + a.Street + "\n" + a.City + ", " + a.State + " " + a.Zip + "\n"
}

使用组合字面量声明一个Struct

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

跑起来试试

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

https://play.golang.org/p/9beVY9jNlW

升级

• 升级会检查一个内部类型是否能知足须要，并“升级”它
• 内嵌的数据域和方法会被“升级”
• 升级发生在运行时而不是声明时
• 被升级的方法被认为是符合接口的

升级不是重载

func (a *Address) String() string {
    return a.Number + " " + a.Street + "\n" + a.City + ", " + a.State + " " + a.Zip + "\n"
}

func (p *Person) String() string {
    return p.Name + "\n" + p.Address.String()
}

外部结构的方法和内部结构的方法都是可见的

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

https://play.golang.org/p/Aui0nGa5Xi

这两个类型仍然是两个不一样的类型

func isValidAddress(a Address) bool {
    return a.Street != ""
}

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

    // 这里不能用 p (Person类型) 做为 Address类型的IsValidAddress参数
    // cannot use p (type Person) as type Address in argument to isValidAddress
    fmt.Println(isValidAddress(p))
    fmt.Println(isValidAddress(p.Address))
}

https://play.golang.org/p/KYjXZxNBcQ

升级不是子类型

多态

为不一样类型的实体提供单一接口

一般经过泛型、重载和/或子类型实现

Go中实现多态的方式

• Go明确避免了子类型和重载
• Go还没有提供泛型
• Go的接口提供了多态功能

接口

• 接口就是（要实现某种功能所须要提供的）方法的列表
• 结构上的类型 vs 名义上的类型
• “若是什么东西能作这件事，那么就能够在这使用它”
• 惯例上就叫它 某种东西

Go语言采用了鸭式辩型，和JavaScript相似。鸭式辩型的思想是，只要一个动物走起路来像鸭子，叫起来像鸭子，那么就认为它是一只鸭子。
也就是说，只要一个对象提供了和某个接口一样（在Go中就是相同签名）的方法，那么这个对象就能够当作这个接口来用。并不须要像Java中同样显式的实现（implements）这个接口。

接口声明

type Shaper interface{ 
    Area() int 
}

而后把这个接口做为一个参数类型

func Describe(s Shaper) {
    fmt.Println("Area is: ", s.Area())
}

这样用

func main() {
    r := &Rect{width: 10, height: 5}
    x := &Rect{width: 7, height: 10}
    rs := &Rects{r, x}
    Describe(r)
    Describe(x)
    Describe(rs)
}

https://play.golang.org/p/WL77LihUwi

“若是你能够从新作一次Java，你会改变什么？”
“我会去掉类class，” 他回答道。
在笑声消失后，他解释道，真正的问题不是类class自己，而是“实现”的继承（类之间extends的关系）。接口的继承（implements的关系）是更可取的方式。
只要有可能，你就应该尽量避免“实现”的继承。
—— James Gosling（Java之父）

Go的接口是基于实现的，而不是基于声明的

这也就是上边所说的鸭式辩型

接口的力量

io.Reader

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

• Interface
• Read方法读取最多len(p) bytes的数据到字节数组p中
• 返回读取的字节数和遇到的任何error
• 并不规定Read()方法如何实现
• 被诸如 os.File, bytes.Buffer, net.Conn, http.Request.Body等等使用

io.Writer

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

• Interface
• Write方法写入最多len(p) bytes的数据到字节数组p中
• 返回写入的字节数和遇到的任何error
• 并不规定Write()方法如何实现
• 被诸如 os.File, bytes.Buffer, net.Conn, http.Request.Body等等使用

io.Reader 使用

func MarshalGzippedJSON(r io.Reader, v interface{}) error {
    raw, err := gzip.NewReader(r)
    if err != nil {
        return err
    }
    return json.NewDecoder(raw).Decode(&v)
}

读取一个json.gz文件

func main() {
    f, err := os.Open("myfile.json.gz")
    if err != nil {
        log.Fatalln(err)
    }
    defer f.Close()
    m := make(map[string]interface{})
    MarshalGzippedJSON(f, &m)
}

实用的交互性

• Gzip.NewReader(io.Reader) 只须要传入一个io.Reader接口类型便可
• 在files, http requests, byte buffers, network connections, ...任何你建立的东西里都能工做
• 在gzip包里不须要任何特殊处理。只要简单地调用Read(n),把抽象的部分留给实现者便可

将 http response 写入文件

func main() {
    resp, err := http.Get("...")
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()
    out, err := os.Create("filename.ext")
    if err != nil {
        log.Fatalln(err)
    }
    defer out.Close()
    io.Copy(out, resp.Body) // out io.Writer, resp.Body io.Reader 
}

Go

简单比复杂更难：你必须努力使你的思惟清晰，使之简单。但最终仍是值得的，由于一旦你到了那里，你就能够移山。 —— Steve Jobs

Go简单，实用，绝妙

Go作了一些伟大的事情