GO语言中的面向对象与接口

GO语言为我们提供了轻量级的面向对象模式，但是不同于JAVA和C++，没有继承这个概念，甚至找不到构造（构析）函数的影子，相对于重量级的面向对象语言，GO语言的面向对象似乎更像硬是用C语言的指针来实现OO。

首先，介绍一下最基本的对象声明,和C语言极为类似：

 

type object struct { some_var int other_var string }

 

里面的变量还可以用指针：

type man struct { name string id int } var woman struct { name string id int husband *man }

type some_object struct 与 var some_object struct是等效的，但是根据$go/doc/GoCourseDay2.pdf中的描述前者更常用。

请注意这个是结构体，里面只能放变量！想要实现类似java中的SomeObject.doSomething()一类的事情得用其他方法，这种试图在结构体内定义函数的方法是错误的：

 

 

type worry_object struct { some_var int some_var string func some_method(i *int) int{ return 100 } }

然后就是使用声明好的结构体了,GO语言提供了new()函数，注意是内置函数不是关键字，这意味着使用new()函数，你得到将是一个指向该结构体的指针：

func main(){ bro_chun := new(man)//故意用很不明确的声明方式 bro_chun.name = "Li_Yuchun" bro_chun.id = 666 fmt.Println("bro_chun name is:" + bro_chun.name) fmt.Print("bro_chun id is:") fmt.Println(bro_chun.id) fmt.Print("what is this?") fmt.Println(bro_chun)//注意这行输出 }

输出：

bro_chun name is:Li_Yuchun bro_chun id is:666 what is this?&{Li_Yuchun 666}//看见了没？是带&的

GO语言还有可以将声明和定义变量放在一起的方式：

bro_zeng := &man{"Zeng_Yike",21} fmt.Println(bro_zeng) output： &{Zeng_Yike 21}

对象的方法：必须理解GO语言中方法与面向对象的关系，GO语言中的方法不在结构体中声明,而是像一个函数一样写在外部，并且在函数前面加上指向这个结构体的指针就算是完成绑定了，然后就可以利用这个绑定的指针使用结构体里的变量了。

首先熟悉一下GO语言中的函数：

func some_func(s string) string { return "lalala~" + s }

func是声明函数关键字，小括号里面写输入参数，可以这样写来输入同类型的参数(i,j int)，后面接的是返回值，上面这个函数返回值是string类型。我们要给前面的man类型的结构体准备一个方法say()来说出自己的名字：

func say() string { return "i cant say my name!"

man还不能说自己的名字，下面我们将这个函数绑定为man的方法：

func (m *man) say() string { return "my name is" + m.name }

仅仅是在函数前面加上要绑定对象的结构体的引用，就可以在函数体中使用了，还有一种方式就是把前面小括号里面的*man换成man，这种方法类似于java的静态方法，由结构体提供某些方法（内部实现与静态方法不同），你不能用这种方法来改变结构体内部变量的值：

package main import "fmt" type man struct { name string id int } func (m *man) change_id(id int){ m.id = id } func (m man) change_id2(id int){ m.id = id } func main(){ m := &man{"nobody",100} m.change_id(50) fmt.Println(m.id) m2 := &man{"somebody",200} m2.change_id2(150) fmt.Println(m2.id)

output:

50

200

第二种改变id的方法是无效的。

接口：这个接口从意义上来说几乎和JAVA是一样的，就是一个或多个方法的集合，GO语言的不同是可以有空接口——能够指向一切类型。接口的声明语法是这样的：

type animal interface { Say() Run() }

剩下的事情就不用管，只管像上面一样绑定方法，而且可以将一种方法绑定到两种对象上去，实现多态：

 

type cat struct { name string } type dog struct { name string } func (c *cat) Say(){ fmt.Println("miao~miao~" + c.name) } func (d *dog) Say(){ fmt.Println("wang!wang!" + d.name) } func (c *cat) Run(){ fmt.Println("wu~~~~~~!") } func (d *dog) Run(){ fmt.Println("ao~~~~~~!") } func main(){ c := &cat{"jiafei"} d := &dog{"putty"} c.Say() d.Say() c.Run() d.Run() }

让cat和dog绑定了animal接口中所有的方法，cat和dog类就实现了anmial接口

output： miao~miao~jiafei wang!wang!putty wu~~~~~~! ao~~~~~~!

 

我们就可以使用animal这个接口作为指向cat或者dog类的指针了：

var a1,a2 animal //注意，这是声明的就是指针类型，不要写成*animal a1 = c a2 = d a1.Run() a2.Run() output： wu~~~~~~! ao~~~~~~! 

 

然后我们在其他地方调用以接口作为输入参数的函数时候灵活性就能大大提升了~哦也！头一次写博客，板砖来吧！