Go语言是面向对象语言吗

这篇文章主要介绍"Go语言是面向对象语言吗"的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇"Go语言是面向对象语言吗"文章能帮助大家解决问题。

1. Go是面向对象的语言吗？

在【Go语言入门系列】（七）如何使用Go的方法？这一文中已经介绍了方法的概念，但这个方法实际上并不是面向对象中的方法。方法实际上是用户给其定义的类型的增加的新行为，实际上也是个函数。

关于这个问题，官方文档中有回答：

Yes and no. Although Go has types and methods and allows an object-oriented style of programming, there is no type hierarchy. The concept of "interface" in Go provides a different approach that we believe is easy to use and in some ways more general. There are also ways to embed types in other types to provide something analogous-but not identical-to subclassing. Moreover, methods in Go are more general than in C++ or Java: they can be defined for any sort of data, even built-in types such as plain, "unboxed" integers. They are not restricted to structs (classes).

Also, the lack of a type hierarchy makes "objects" in Go feel much more lightweight than in languages such as C++ or Java.

既是也不是。尽管Go拥有类型和方法，也允许面向对象风格的编程，但它没有类型层级。 在Go中"接口"的概念提供了不同的方法，我们相信它易于使用且在某些方面更通用。 也有一些在其它类型中嵌入类型的方法，来提供类似（而非完全相同）的东西进行子类化。 此外，Go中的方法比C++或Java中的更通用：它们可被定义为任何种类的数据。 甚至是像普通的"未装箱"整数这样的内建类型。它们并不受结构（类）的限制。

此外，类型层级的缺失也使Go中的"对象"感觉起来比C++或Java的更轻量级。

有了这个回答，下面介绍的"继承"和"重写"的概念并不是严格的面向对象中的继承和重写的概念。这里只借用这两个名词来表示Go的两种特性。

2."继承"

在面向对象中，继承是子类和父类之间的关系，子类会继承父类的公有成员变量和成员方法。

前面提到过，Go允许面向对象风格的编程。那Go如何"继承"呢？

2.1."继承"字段

在【Go语言入门系列】（五）指针和结构体的使用这一文中，介绍了匿名字段（也叫嵌入字段）：

package mainimport "fmt"type people struct {        name string        age int}type student struct {        people        school string}func (s student) say() {        fmt.Printf("我是%s，今年%d岁了，在%s上学。", s.name, s.age, s.school)}func main() {        stu := student{people{"行小观", 1}, "阳光小学"}        stu.say()}

运行：

我是行小观,今年1岁了,在阳光小学上学

结构体student中有匿名字段people，所以student就有了people的name和age字段。当匿名字段是一个结构体时，那么该结构体的全部字段都会被引入当前的结构体中。这是不是很像面向对象中的继承？子类继承父类的公有成员变量。

考虑下面一个问题，如果student和people中都有name字段，那么访问时，Go语言是如何处理的？

package mainimport "fmt"type people struct {        name string //人名        age int}type student struct {        people        name string //学生名        school string}func main() {        stu := student{people{"李二狗", 1}, "李向前", "阳光学校"}        fmt.Println(stu.name) //李向前        fmt.Println(stu.people.name) //李二狗}

此时就出现了字段冲突，Go会先访问外层的字段。比如，stu.name是李向前（外层），stu.people.name是李二狗（内层）。

2.2."继承"方法

我们通过接收者把函数绑定到结构体类型上，这样的函数称为方法，方法就在概念上属于了接收者对应的结构体。

上面通过结构体中匿名字段实现了"继承"字段的效果，对于方法来说，同样可以。下面是一个实例：

package mainimport "fmt"type people struct {        name string        age int}type student struct {        people        school string}type programmer struct {        people        language string}func (p people) say() {        fmt.Printf("我是%s，今年%d岁了，和我一起学习Go语言吧！\n", p.name, p.age)}func main() {        stu := student{people{"行小观", 1}, "阳光小学"}        stu.say()        prom := programmer{people{"张三", 1}, "蓝天建筑有限公司"}        prom.say()}

运行：

我是行小观，今年1岁了，和我一起学习Go语言吧！我是张三，今年1岁了，和我一起学习Go语言吧！

say()方法的接收者是people类型，而结构体student和programmer中都有匿名字段people，所以stu和prom都能调用say()方法。这是不是很像面向对象语言中子类继承父类的公有方法？

3. "重写"

3.1. "重写"字段

前面已经介绍了如果结构体和作为其字段的结构体的字段冲突了如何处理。有了这个特性，我们就可以"重写"字段。

package mainimport "fmt"type people struct {        name string //乳名        age int}type student struct {        people        name string //大名        school string}func (s student) say() {        fmt.Printf("我是%s，今年%d岁了，和我一起学习Go语言吧！\n", s.name, s.age)}func main() {        stu := student{people{"李二狗", 1}, "李向前","阳光小学"}        stu.say()}

运行：

我是李向前，今年1岁了，和我一起学习Go语言吧！

李二狗是乳名，李向前才是大名。自我介绍时说的是大名李向前。如果需要乳名，则使用stu.people.name。

3.2."重写"方法

下面是一个实例：

package mainimport "fmt"type people struct {        name string        age int}type student struct {        people        school string}type programmer struct {        people        language string}func (p people) say() { //people的say方法        fmt.Printf("我是%s，今年%d岁了，和我一起学习Go语言吧！\n", p.name, p.age)}func (s student) say() { //student重写people的say方法        fmt.Printf("我是%s，是个学生，今年%d岁了，我在%s上学！\n", s.name, s.age, s.school)}func (p programmer) say() { //programmer重写people的say方法        fmt.Printf("我是%s，是个程序员，今年%d岁了，我使用%s语言！\n", p.name, p.age, p.language)}func main() {        stu := student{people{"李向前", 1}, "阳光小学"}        stu.say()        prmger := programmer{people{"张三", 1}, "Go"}        prmger.say()}

运行：

我是李向前，是个学生，今年1岁了，我在阳光小学上学！我是张三，是个程序员，今年1岁了，我使用Go语言！

student和programmer"继承"了people的say()方法，但是不合适，于是各自"重写"了say()方法。

看到这里，你就理解了官方文档中的那两句话是什么意思了。

"尽管Go拥有类型和方法，也允许面向对象风格的编程，但它没有类型层级"

"类型层级的缺失也使Go中的"对象"感觉起来比C++或Java的更轻量级"

关于"Go语言是面向对象语言吗"的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识，可以关注行业资讯频道，小编每天都会为大家更新不同的知识点。