我们都知道，面向对象有三大特征：封装，继承和多态
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式
继承：子类能具有父类的属性和方法，可以在父类的基础上追加或者重定义相应的属性和方法
多态：不同类的对象可以以相同的方式调用同一个方法，但这些对象的实现可能不同。
golang里面虽然没有class这一概念，但是面向对象是一种编程思想，golang也是支持通过struct实现面向对象编程的。
1. 封装
golang中的封装主要通过结构体(struct)和方法（method）实现.
结构体是类(class)的一种简化形式，存储对象的属性（之前的博客有介绍，这里不重复介绍了），比如，所有人都有姓名和年纪，因此我们可以定义一个Person
type Person struct {age intName string
}1.1 方法
方法（method）是一种特殊类型的函数，golang中的方法是作用在接收者上的函数，接收者是某种类型的变量，定义方法的格式如下：
func (r ReceiverType) funcName(parameters) (returnValues)上面我们已经定义了一个结构体Person，现在我们需要获取他的姓名，应该如果通过方法实现呢？代码如下：
package mainimport "fmt"type Person struct {Name stringage int
}func (p *Person) GetName() string {return p.Name
}func main() {p := &Person{"lilei", 12}fmt.Println(p.GetName())
}
代码中我们定义了一个Person结构体的方法GetName，在这个方法里我们可以直接访问到接收者的属性，不同的接收者的属性不一样。我们可以对任意结构体实现任意的的方法。
1.2 访问权限
golang里面没有private, public之类的关键字来控制一个类的属性是私有的还是公有的，而是通过首字母大小来控制公开性
- 首字母大写的属性和方法是公共的，可以被包外访问；
- 首字母小写的属性和方法是私有的，只能在定义它们的包内访问。
举个例子，我们将Person的类型名和属性都改为小写，例子如下
目录位置：test/model/person.go，定义了一个包
package modeltype person struct {name stringage int
}func NewPerson(name string, age int) *person {return &person{name: name,age: age,}
}func (p *person) GetName() string {return p.name
}
然后在test/main/main.go中引入该包，我们在main.go中只能通过调用NewPerson和GetName两个方法去操作对应的属性
package mainimport ("fmt""test/model"
)func main() {p := model.NewPerson("lilei", 12)fmt.Println(p.GetName())
}
其它的age等在main包中都是不可见的。这里通过大小写的方式就控制了属性和方法的访问权限。
综上，依靠结构体，方法，大小写就达到的面向对象编程中的封装效果。
2. 继承
golang里面没有类似extends的关键字来实现继承，它是通过内嵌结构体的方式来实现继承的。
比如我们上面定义的person结构体，里面实现了一个GetName的方法，现在我们定义两个继承person结构体的结构体，分别为student, teacher，同时增加对应的构造函数
type student struct {personclass string
}type teacher struct {personschool string
}func NewStudent(name string, age int, class string) *student {return &student{person: person{name, age},class: class,}
}func NewTeacher(name string, age int, school string) *teacher {return &teacher{person: person{name, age},school: school,}
}
然后我们在主函数中分别构造一个teacher和一个student，构造完后，这两个结构体就可以调用person的方法GetName了
package mainimport ("fmt""test/model"
)func main() {student := model.NewStudent("lilei", 12, "A")fmt.Println(student.GetName())teacher := model.NewTeacher("zhangsan", 34, "yizhong")fmt.Println(teacher.GetName())
}
通过内嵌结构体的方式，"子类"student和teacher都可以调用"父类"person的方法，这就实现了继承。
3. 多态
什么是多态，多态是指同一操作或函数在不同对象上具有不同的表现形式和行为。
在golang中，多态是通过接口实现的。现在我们已经定义了student和teacher两个结构体，现在需要将它们分别实现同一个方法introduce，用来做自我介绍，而且希望它们在调用这个方法时行为不一样。我们按照如下方式增加一个接口并分别实现它
// 定义一个接口
type Speaker interface {Speak() string
}// 实现接口 Speaker 的 Speak 方法
func (student student) Speak() string {return fmt.Sprintf("Hi, I'm %s and I'm %d years old, and study in class %s", student.name, student.age, student.class)
}// 实现接口 Speaker 的 Speak 方法
func (teacher teacher) Speak() string {return fmt.Sprintf("Hi, I'm %s and I'm %d years old, and work in school %s", teacher.name, teacher.age, teacher.school)
}// 接受一个 Speaker 接口类型的参数
func Introduce(s Speaker) {fmt.Println(s.Speak())
}然后我们在主函数中分别传入student和teacher对象就可以分别执行不同的方法了
package mainimport ("test/model"
)func main() {student := model.NewStudent("lilei", 12, "A")teacher := model.NewTeacher("zhangsan", 34, "yizhong")model.Introduce(student)model.Introduce(teacher)
}
最后运行结果为
就这样，不同的类型可以被同一接口处理，这样就达到多态的效果了。
