前言
go语言因为产生时代的原因，大神们在设计go时，不得不考虑业界的流行趋势（编程理念），使得go既可以面向过程编程，也可以面向对象编程。这里不探讨两者的优劣，存在即是合理，面向过程编程经久不衰，而面向对象当今红红火火。如题所示，本文只计划聊一聊go的面向对象编程。
语法
面向对象离不开其三大特性，封装、继承、多态。那么go在语法层面是怎么实现这个的呢？
先来看一下封装，示例如下：
type House struct {//House是大写开头，公开类型，相当于java的public class
Name string //大写表示公开属性，即java的public
height float32 //小写表示私有属性，即java的private
width float32
}
//方法名大写表示公开方法，即java的public方法
func (h *House) Height() float32 {
return h.height
}
func (h *House) Width() float32 {
return h.width
}
func (h *House) Area() float32 {
return h.height * h.width
}
从上述代码可以看出，go语法的封装完全依赖属性名或方法名开头字母的大小写来声明，大写表示公开，小写表示私有。这无不体现go语言大道至简的特点。但在go语言中，它不叫封装，它叫导出。导出的类型、属性、方法在包外可见。
再看一下继承，示例如下：
package main
import "fmt"
func main() {
wh := WhiteHouse{House: House{height: 1.0, 2.0, name: "abc"}, Building: Building{name: "xyz"}}
//fmt.Println(wh.getName()) //此句会报多义的错误
fmt.Println(wh.height) //获得了House的属性
fmt.Println(wh.House.GetName()) //需要显式地指定调用哪个组合类型的方法
fmt.Println(wh.Building.GetName())
}
type House struct {
height float32
width float32
name string
}
func (h *House) GetName() string {
return h.name
}
type Building struct {
name string
}
func (b *Building) GetName() string {
return b.name
}
type WhiteHouse struct {
House //组合方式的继承，获得了House的属性及方法
Building //组合方式的继承，获得了Building的属性及方法
}
所谓继承，宽泛的理解应该是获得已有类型的属性或方法，从而达到代码简化及复用的目的。而往具体了说则是具有一定从属关系、父子关系或等级关系的对象之间的一种强关联的关系，目的不仅仅是为获得与复用，而是同时声明了一种关系。
关于继承，以下这几种语言的实现是最具有代表性的。
| 语言 | 继承方式 | 关键词 | 说明 |
|---|---|---|---|
| java | 单继承 | extends, interface | 规避类的复杂性及多义性；但仍可以通过接口实现多继承，可见下面的代码示例 |
| python | 多继承 | MRO，菱形继承，C3算法 | - |
| c++ | 多继承 | 虚基类, virtual | - |
| javascript | 原型链 | prototype，constructor | - |
| go | 组合继承 | embedded, duck | - |
java多继承示例：
public class Z {
public void z() {
}
}
public interface A {
void x();
}
public interface B {
void x();
}
//AB将会继承得到Z的方法z
//通过实现A、B两个接口的同名方法，得到自己专属的x方法实现，不存在多义的问题
public class AB extends Z implements A, B {
@Override
public void x() {
}
}
public interface C {
default void y() {
System.out.println("C->y");
}
}
public interface D {
default void y() {
System.out.println("D->y");
}
}
//此处会报编译错误，必须覆盖y方法。这是java从语言规范层面规避多义问题
public class CD extends Z implements C, D {
}
javascript多继承示例：
//以下代码摘自大神阮一峰《Javascript面向对象编程（二）：构造函数的继承》一文
//在此拜谢
function Animal() {
this.species = "动物"
}
function Cat(name, color) {
this.name = name;
this.color = color;
}
//从这个函数里可以得知，javascript的继承有点简单粗暴的意思，相当于直接复制。
function Extend(Child, Parent) {
var F = function{};
F.prototype = Parent.prototype;
Child.prototype = F.prototype;
Child.prototype.constructor = Child;
Child.uber = Parent.prototype;
}
Extend(Cat, Animal);
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物
而python与C++都支持多继承，只不过两者对多继承多义的处理不一样。前者是通过MRO解决，后者则是通过virtual关键字解决。
通过比较可以看出，go语言的继承是一种弱关系的继承，专心完成属性与方法的获得，以及代码复用。而这种继承方式也导致不支持继承类型间的转换，即上述代码中的WhiteHouse是不能转换为House或Building类型的。
在go中，如果要表达类似的强关系，只能通过interface来完成。但请注意，go的interface的概念依然不同于上述的java、c++语言，它不要求"实现了某个接口的类必须要实现接口中未实现的方法"，而只是轻松写意地说道："你只要实现这些个方法，那么你就实现了这些个接口"。 这两个说法有什么不同呢？虽然可以很明显地感觉后者的自由度更大，且看下文分解。
最后是多态。多态是同一个行为具有多个不同表现形式或形态的能力。体现在编程语言中就是同一个接口，在运行时因为不同的实例而执行不同操作。示例如下：
pckage main
import "fmt"
func main() {
//同一个对象g，不同的实例会有不同的表现(输出)
g := Machinegun{}
g.Fire()
g = Handgun{}
g.Fire()
}
type Gun interface {
Fire()
}
type Machinegun struct {
}
func (m *Machinegun) Fire() {
fmt.Println("machinegun fire")
}
type Handgun struct {
}
func (h *Handgun) Fire() {
fmt.Println("handgun fire")
}
在多态这一点上，存在接口概念的语言都有大体相同的代码写法。只是go还是一种支持鸭子类型的语言，尽管没有python这种动态类型语言做得那么淋漓尽致。请上代码如下：
python代码示例：
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
class Animal(object):
def __init__(self, name):
self.name = name
def walk(self):
print(self.name + "在散步")
class Cat(Animal):
pass
class Dog(Animal):
pass
class Abc(object):
def walk(self):
print("abc" + "在走路")
def hello(animal):
animal.walk()
if __name__ == "__main__":
c = Cat("小猫")
hello(c)
d = Dog("小狗")
hello(d)
//鸭子类型在这里体现得相当完美
//Abc并没有继承Animal，但却可以作为hello方法的参数
//而在静态语言中，就必须传递Animal的子类
abc = Abc()
hello(abc)
所谓鸭子类型，维基百科解释为：duck typing in computer programming is an application of the duck test — "If it walks like a duck and it quacks like a duck, then it must be a duck"。
鸭子类型得益于实现时不测试方法或函数中参数的类型，而依赖于文档以及清晰的代码和测试来保证正确使用，当然如果文档不完善，就只能靠查看代码才知道如何使用，这也是其缺点。
同时，鸭子类型使得Animal即使在后续的版本中增加方法，而旧的实现类仍未实现该新方法，升级版本后，也不会影响已有代码的使用。而这一点在以前的java中是做不到的，因而直接导致java 8接口中default语法的出现。
鸭子类型可以使得不用太关注对象类型，而转而关心对象的行为或能力。
那么在go中，鸭子类型是如何体现的呢？
package main
import "fmt"
func main() {
c := &Cat{}
hello(c)
abc := &Abc{}
hello(abc)
}
func hello(animal interface{}) {
animal.(Animal).walk()
}
type Animal interface {
walk()
//run()
}
type Cat struct {
}
func (c *Cat) walk() {
fmt.Println("小猫在散步")
}
type Abc struct {
}
func (a *Abc) walk() {
fmt.Println("abc在走路")
}
示例中的hello方法，因为interface{}神一般的存在，使得作为静态类型的go语言，可以模拟动态语言的写法。但似乎只是go真的只是鸭子类型语言而已，真的只是实现了鸭子类型的概念而已，其并没有动态语言的那种关于鸭子类型灵活性与自由度。
请关注公众号
