go 中的面向对象

前言
有过C++语言学习经历的朋友都知道，面向对象主要包括了三个基本特征：封装、继承和多态。封装，就是指运行的数据和函数绑定在一起，C++中主要是通过this指针来完成的；继承，就是指class之间可以相互继承属性和函数；多态，主要就是用统一的接口来处理通用的逻辑，每个class只需要按照接口实现自己的回调函数就可以了。
作为集大成者的Go语言，自然不会在面向对象上面无所作为。相比较C++、Java、C#等面向对象语言而言，它的面向对象更简单，也更容易理解。
go语言中并没有像C++，Java语言中这类的Class，它只含有像C语言中的结构体，用结构体和指针等特性，完成一个类的作用，很巧妙的使用了指针和结构体，不仅是go的面向对象，包括go语言中的map等操作都是借助了结构体。其实，说白了，C++、Java等面向对象的语言中，类的底层实现就是结构体，对象的引用就是指针，只是语言把他们封装起来了而已。然而这使得很多人刚接触面向对象的时候很不理解这些东西。
下面，说所面向对象在go中的写法：
如果我们要再Java中定义一个Rect，可以求其面积，我们应该这么写

public class Rect {
public int x;
public int y;
public int Area() {
return x*y;
}
}
很简单，那么Go语言中怎么做呢？Go中并不存在所谓的类，所有的类都是用结构体表示的，所以要写一个类，我们先得定义一个结构体：

type Rect struct {
x, y int
}
这是一个Rect的结构体，那么一个类中，不仅要存在变量，还要有成员函数，那么go的成员函数是这么写的：

func (r *Rect) Area() int {
return r.x*r.y
}
这个成员函数的功能是求面积的，显然，这个成员函数值对Rect的结构体适用，这样就实现了所谓的封装，那么，我们如何去创建并初始化类的实例呢
go语言提供了很多方式：

rect :=new(Rect)
rect :=&Rect{}
rect :=&Rect{1,2}
rect :=&Rect{x:3,y:4}
那么，一遍情况下，如果没有指定成员变量的大小，go语言会默认初始化成员变量为0，bool类型的为false。
那么，构造函数呢？
我们可以这么来写：

func NewRect(x,y int) *Rect {
return &Rect{x,y}
}
其实，这也是我们平时new一个对象时候的真正操作，只是go把他真正展现给我们了。
看到这里，我们似乎还有一个疑问，那就是，像java、C++中对于可见性的描述呢，go语言中不存在public等关键字，go语言中直接选择用字母大小写控制。
一个变量以大写字母开头则表示对其他包可见，如果想要不可见，那么使用小写字母即可，但是go语言中的可见性控制只是针对包的，并不针对类，也就是，同一个包下的类都是可见的。这个时候我们就可以知道了为什么输出语句是这样写的了吧：

fmt.Println(“hello world”)
因为此函数对其他包是可见的。
总结
以上就是GO语言面向对象的全部内容，希望这篇文章的内容对大家学习或者使用GO语言能有所帮助，如果有疑问大家可以留言交流。

1、结构体 struct
定义格式：
type 结构体名称 struct {
属性1 类型
属性2 类型
…
}
结构体的初始化可以使用new关键词和var关键词，不同的是如果使用new，则返回类型是一个指针，使用var，则是结构体自身。
type User struct {
name string
age int
}

user := new(User)
user.name = “tom”
user.age = 20

fmt.Println(user) //输出&{tom 20}
上例中使用new来初始化一个结构体，user的类型就是*User，在输出内容中的&字符号也表现了这点。接下来看下使用var的情况：
type User struct {
name string
age int
}

var user User
user.name = “tom”
user.age = 20

fmt.Println(user) //输出{tom 20}
这里输出中没有&符号了。
如果结构体属性比较多，每个属性初始化都要一行，代码就显的比较冗长，Go语言提供更简洁的写法：
type User struct {
name string
age int
}

user := User{“tom”, 20} //按顺序给属性赋值
//user := User{age: 20, name: “tom”} //指明属性赋值
fmt.Println(user)
要注意的就是如果不指明属性，就是按照结构体内属性的先后顺序进行赋值。
2、数组 array
数组使用很广泛，很多语言都有会有数组的实现。
定义格式：
[长度]类型{初始化值}
其中长度可以省略或者换成三个点“…”，如果这么做的话，系统会根据初始化的值自动定义数组的长度。
简单的示例：
arr := [2]int{3, 2}
//arr := []int{3, 2}
//arr := […]int{3, 2}
fmt.Println(arr) //输出[3 2]
如果指明了长度，但是没有初始值，则会根据数组类型初始化每个值
arr := [5]int{}
fmt.Println(arr) //输出[0 0 0 0 0]
3、切片 slice
切片可以和数组很好的配合使用，可以用来获取数组中一段数据。格式：
数组变量[开始索引：结束索引]
其中不包括结束索引。
arr := [5]int{3,4,5,6,7}
slice := arr[0:3]
fmt.Println(slice) //输出[3 4 5]
切片也可以用于字符串：
str := “Anny is a beautiful girl.”
fmt.Print(str[0:6]) //输出Anny i
4、字典 map
在Go语言数组中，字符串是不能做键值的，我觉着字典很好的弥补了这个不足。
字典定义格式：
map[键类型] 值类型 {
键: 值,
….
}
一个简单示例：
ages := map[string] int {
“tom”: 21,
“anny”: 18,
}

fmt.Println(ages[“tom”])
使用字典时，还能动态添加字典元素，也很方便。
ages := map[string] int {
“tom”: 21,
“anny”: 18,
}

ages[“jack”] = 20

fmt.Println(len(ages))
如果键在字典里是不存在的，则返回一个默认值，默认值根据不同的类型决定。
ages := map[string] int {
“tom”: 21,
“anny”: 18,
}

fmt.Println(ages[“jack”]) //输出0
 
转载请注明：快乐编程 » Go语言的复合数据类型struct，array，slice，map
golang中并没有明确的面向对象的说法，实在要扯上的话，可以将struct比作其它语言中的class。
类声明
type Poem struct {
Title string
Author string
intro string
}
这样就声明了一个类，其中没有public、protected、private的的声明。golang用另外一种做法来实现属性的访问权限：属性的开头字母是大写的则在其它包中可以被访问，否则只能在本包中访问。类的声明和方法亦是如此。
类方法声明
func (poem *Poem) publish() {
fmt.Println(“poem publish”)
}
或者
func (poem Poem) publish() {
fmt.Println(“poem publish”)
}
和其它语言不一样，golang声明方法和普通方法一致，只是在func后增加了poem Poem这样的声明。加和没有加*的区别在于一个是传递指针对象，一个是传递值对象。
实例化对象
实例化对象有好几种方式
poem := &Poem{}
poem.Author = “Heine”
poem2 := &Poem{Author: “Heine”}
poem3 := new(Poem)
poem3.Author = “Heine”
poem4 := Poem{}
poem4.Author = “Heine”
poem5 := Poem{Author: “Heine”}
实例化的时候可以初始化属性值，如果没有指明则默认为系统默认值
加&符号和new的是指针对象，没有的则是值对象，这点和php、java不一致，在传递对象的时候要根据实际情况来决定是要传递指针还是值。
tips：当对象比较小的时候传递指针并不划算。
构造函数
查看官方文档，golang并没有构造函数一说。如果一定要在初始化对象的时候进行一些工作的话，可以自行封装产生实例的方法。
func NewPoem(param string, p …interface{}) *Poem
示例：
func NewPoem(author string) (poem *Poem) {
poem = &Poem{}
poem.Author = author
return
}

poem6 := NewPoem(“Heine”)
继承
确切的说golang中叫做组合（composition）
type Poem struct {
Title string
Author string
intro string
}

type ProsePoem struct {
Poem
Author string
}
ProsePoem属性中声明了Poem，表示组合了Poem的属性和方法。可以像如下方式调用：
prosePoem := &ProsePoem{}
prosePoem.author = “Heine”
如果其中属性有冲突，则以外围的为主。
type ProsePoem struct {
Poem
Author string
}
当访问Author的时候默认为ProsePoem的Author，如果需要访问Poem的Author属性可以使用prosePoem.Poem.Author来访问。
prosePoem := &ProsePoem{}
prosePoem.Author = “Shelley”
prosePoem.Poem.Author = “Heine”
fmt.Println(prosePoem)
从输出中可以很直观看到这一点。
&{{ Heine } Shelley}
方法的继承和属性一致，这里不再罗列。通过组合的话可以很好的实现多继承。
方法重载
方法重载就是一个类中可以有相同的函数名称，但是它们的参数是不一致的，在java、C++中这种做法普遍存在。golang中如果尝试这么做会报重新声明（redeclared）错误，但是golang的函数可以声明不定参数，这个非常强大。
func (poem *Poem) recite(v …interface{}) {
fmt.Println(v)
}
其中v …interface{}表示参数不定的意思，其中v是slice类型，fmt.Println方法也是这样定义的。如果要根据不同的参数实现不同的功能，要在方法内检测传递的参数。
接口
关于面向对象中还一个重要的东西就是接口了，golang中的接口和其它语言都不太一样，是golang值的称道设计之一。详细了解接口还需要一段时间，下次再分享吧。
完整的示例代码下载：golang面向对象示例代码
 
转载请注明：快乐编程 » golang面向对象思想和实现