Go语言与面向对象编程

lxy15329 · · 2619 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

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

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

面向对象的三大特点:封装、继承、多态。

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

// 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)
}

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

func (ptype) funcName(a type)(btype){}

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

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

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

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

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

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())

}

还是刚才的代码,我只是在主函数所在的包中又增加了一个结构体,它包含了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中也有接口,只是其实现方式比较奇怪一些,闲话少说,还是拿例子说事:

// 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
}

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

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())
}

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

 

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




本文来自:CSDN博客

感谢作者:lxy15329

查看原文:Go语言与面向对象编程

入群交流(和以上内容无关):加入Go大咖交流群,免费领全套学习资料或添加微信:muxilin131420 备注:入群;或加QQ群:729884609

2619 次点击  ∙  2 赞  
加入收藏 微博
上一篇:Go语言 指针
下一篇:Golang闭包
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传