Go语言与面向对象编程

<span style="font-size: 18px;">学习Go语言差不多快两个月了，感觉这个过程还是蛮快乐的，翻翻英文资料，写写小程序，总是觉得有好多东西都搞不明白，一步步走下来，却发现，这些迷惑好像也是不可或缺的。慢慢思考，最终也找到了解决方法，可能不是最好的，但是我会随着认识的不断深入，继续修改。</span>

<span style="font-size: 18px;">因为java的东西在我的知识体系中是根深蒂固的，尽管我现在很讨厌java体系中的一些东西。对于曾经搞过java的人来说，去学习任何一门新的语言，首先会问，是否是面向对象的语言。刚接触GO的几天，曾经带我的师傅问我go是不是一门面向对象的语言，我闪烁其词，因为我还没有搞清楚到底是不是。面向对象思想是一种很好得方法（到目前来说我认为还是这样）。Go严格来说不是一门面向对象的语言，但是，其中的很多方式还是借鉴了面向对象的一些思想，尽管Go更接近C，但是从面向对象这块，从事java的开发人员还是不陌生的。</span>

<span style="font-size: 18px;">面向对象的三大特点：封装、继承、多态。</span>

<span style="font-size: 18px;">封装：就我自己的理解而言，封装就是将某些特征组装到一起，其他的对象或类可以使用这个整体，却不一定能够知道其实现细节。这又涉及到是否可见的问题。在java中，有privat,public,protected关键字来决定访问的权限。而在go中，采用了一种算是规定的方法：使用大小写来确定，大写是包外可见的，小写的struct或函数只能在包内使用。（go的关键字是及其少，简直可以说是吝啬，这也是其简洁的一个原因吧）。Java中，每个class都有其属性和方法，在go中，没有class的概念，与C语言一样，有struct的概念。与C语言不同的是，可以定义只用于这个struct的方法。看个例子会清晰很多。</span>

<span style="font-size: 18px;"></span>

<pre><code>// lxy project lxy.go package lxy import "strconv" type Student struct { Name string Age int } func (s *Student) SetName(name string) { s.Name = name } func (s *Student) GetName() string { return s.Name } func (s *Student) SetAge(age int) { s.Age = age } func (s *Student) GetAge() int { return s.Age } func (s *Student) String() string { return "name is " s.Name ",age is " strconv.Itoa(s.Age) } </code></pre>

先说一下在go中函数定义的格式吧。

<span style="color: red;">func </span><span style="color: rgb(0, 176, 80);">(ptype) </span>funcName(a type)<span style="color: rgb(112, 48, 160);">(btype)</span>{}

红色的func是定义函数的关键字，是不可变的，绿色部分是可选的，当然，如果有这部分，那就不是个函数了，而是一个方法。这种实现方式相当于是定义了，这个方法只用于这个type的实例。紫色部分代表的是函数的返回值。这个有点奇怪啊。向我们熟悉的语言，不管是java还是C，都会把返回值放在函数名前边，go却把它放到了最后。还有，go中的函数可以有0-n个返回值，并且可以指定返回值的名字。

结构体Student封装了两个方法，Name和Age，这两个熟悉包括结构体都是包外可以使用的。然后又给这个结构体定义了几个方法。看一下在主函数中的调用。

<pre><code>package main import ( "fmt" "lxy" ) func main() { ss := new(lxy.Student) ss.SetName("lxy") ss.SetAge(20) fmt.Println(ss.String()) } </code></pre>

在go中，要想调用另外一个package中的内容，需要首先import.在go中，所有的都会在一个特定的包中定义或者使用。使用方式为包名.(方法或者全局变量)

继承：在go中，没有明确说明继承的关键字，我使用的，我不确定是否是真正意义上的继承，姑且称之为模拟继承吧。还是看例子。

<pre><code>package main import ( "fmt" "lxy" ) type director struct { lxy.Student Name string } func (di *director) GetName() string { fmt.Println("get director name") return di.Name } func main() { ss := new(lxy.Student) ss.SetName("lxy") ss.SetAge(20) dd := new(director) dd.Name = "director" dd.Student = *ss fmt.Println(dd.GetName()) fmt.Println(dd.Student.GetName()) fmt.Println(dd.GetAge()) } </code></pre>

还是刚才的代码，我只是在主函数所在的包中又增加了一个结构体，它包含了Student，而且是匿名包含的，这实际上就是一个继承。Director的实例可以直接调用Student中的所有方法，如最后一条语句。对于一些冲突的处理包括：像本例中，director中包含了GetName方法和Name属性，与Student中是完全一样的，因为这个没有出现在同一个level(何为同一个lever呢？本例中，director中的Name和lxy.Student就是同一个level)，所以调用的是level最高的。若是处于同一个level的包含相同的变量名或者方法名，那就必须要明确指明了。比如

type A struct{

 a int

 b string

}

type B struct{

 a int

 c string

}

type C struct{

A

B

}

此时调用var cc C;cc.a 就错了，因为编译器不清楚到底是A还是B的a属性，这个需要指明是cc.A.a还是cc.B.a

多态：这个概念该怎么说呢，接口的多种不同实现方式。比如一个接口方法：叫。如果猫实现了这个接口，则结果会是“喵喵”；狗实现了这个方法，结果会是“汪汪”…..go中也有接口，只是其实现方式比较奇怪一些，闲话少说，还是拿例子说事：

<pre><code>// lxy project lxy.go package lxy import "strconv" type IPeople interface { SetName(string) GetName() string } type Student struct { Name string Age int } type Teacher struct { Name string Course string } func (s *Student) SetName(name string) { s.Name = name } func (t *Teacher) SetName(name string) { t.Name = name } func (s *Student) GetName() string { return s.Name } func (t *Teacher) GetName() string { return t.Name } func (s *Student) SetAge(age int) { s.Age = age } func (s *Student) GetAge() int { return s.Age } func (s *Student) String() string { return "name is " s.Name ",age is " strconv.Itoa(s.Age) } func (t *Teacher) SetCourse(course string) { t.Course = course } func (t *Teacher) GetCourse() string { return t.Course } </code></pre>

代码中红色部分定义了一个接口IPeople，其包括两个方法。上述代码，我们可以得出一个结论，Teacher和Student都实现了接口IPeople.还没看出来是吧。因为Teacher和Student都实现了接口IPeople的两个方法。在go中，不需要显示声明某个struct是否声明了接口，只要其包括接口中的方法，go编译器就认为这个struct实现了这个接口了。即使接口与这个struct不在同一个包中，也会认为是实现了这个接口。看下主函数中：

<pre><code>package main import ( "fmt" "lxy" ) type director struct { lxy.Student Name string } func (di *director) GetName() string { fmt.Println("get director name") return di.Name } func (di *director) SetName(name string) { di.Name = name } func main() { ss := new(lxy.Student) ss.SetName("lxy") ss.SetAge(20) dd := new(director) dd.Name = "director" dd.Student = *ss var ii lxy.IPeople ii = dd ii.SetName("test") fmt.Println(ii.GetName()) } </code></pre>

一个struct可以实现多个接口，一个接口也可以被多个struct实现，这些与大家熟知的面向对象语言相同。接口在go语言中是很重要的一种结构，其意义远比在java中深远。具体的大家可以参考下go的学习资料。

 

差不多吧，我想到且知道的就是这些，虽然不是严格意义上的面向对象，但是最起码做到了神似。

您可能感兴趣的文章：
go语言和python哪个难
Go语言学习3----Go语言特色
Go语言发展历史、核心、特性及学习路线
Go语言的主要特性和发展影响
Go 语言到底适合干什么？
面向对象的程序设计语言是一种什么语言
Go核心编程－面向对象 [OOP]
关于Golang的介绍
兄弟连golang神技（1）-关于 Go 语言的介绍
Go 语言十年而立，Go2 蓄势待发