Go 面向对象

引言

Go 的面向对象，语法清奇，思路独特，和传统的面向对象语言如 Java 完全不同，可开阔思路。

结构体

谈到面向对象，就不得不提其载体 struct

type 结构体名称 struct{
    field1 type
    field2 type
}

以上便是其定义的语法，使用也很简单

type Student struct {
	Name,Address string
	Age int
	Score float64
}

定义了个 Student 的结构体，里面有几个常用的字段。以下为引用的一种方法

alice := Student{"molaifeng", "北京", 32, 99.5}

方法

在 Go 中，方法是指定在数据类型上的，因此如果给上面的 student 结构体指定特有的方法，只需如此做

func (this Student) Speak(str string) {
	fmt.Println(str);
}

使用刚刚定义的方法

func main() {
	alice.Speak("My name is Alice")
}

面向对象三大特性之封装

其实这个特性和上述介绍的方法一致，因为方法对外提供接口并隐藏实现细节。

面向对象三大特性之继承

继承可以解决代码复用，当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体(比如刚才的Student),在该结构体中定义这些相同的属性和方法。

type Pupil struct {
	Student
}

type Graduate struct {
	Student
}

当然了，结构体也可以实现多重继承，这里就不展开介绍了。

接口

介绍多态之前，还得宕开一笔说下接口，因为这个是实现多态的基础。

interface 类型可以定义一组方法，但是这些不需要实现。并且 interface 不能包含任何变量。到某个自定义类型(比如结构体 Student)要使用的时候，在根据具体情况把这些方法写出来。

type 接口名 interface {
    method1(参数列表) 返回值列表
    method2(参数列表) 返回值列表
}

func (t 自定义类型) method1(参数列表) (返回值列表) {
    //方法实现
}

func (t 自定义类型) method2(参数列表) (返回值列表) {
    //方法实现
}

需要说明的是，Go 中的接口，不需要显式的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，Go 中没有 implements 这样的关键字。

type Repeat interface {
	Say()
}

func (s *Student) Say() {
	fmt.Println(s.Name)
}

func main()  {
	var re Repeat = alice
	re.Say()
}

还有另一个重要的特点，空接口 interface{} 没有任何方法，所以所有类型都实现了空接口。

type T interface {

}

func main()  {

	// Stutent 默认实现了空接口
	var t T = alice
	fmt.Println(t)

	var t1 interface{} = alice
	num := 8.8
	fmt.Println(t1)
	t1 = num
	fmt.Println(t1)
}

接口和继承

package main

import "fmt"

type Monkey struct {
	Name string
}

func (this *Monkey) climbTree()  {
	fmt.Println(this.Name, " 生来会爬树")
}

type LittleMonkey struct {
	Monkey
}

type BirdAble interface {
	Flying()
}

type FishAble interface {
	Swimming()
}

func (this *LittleMonkey) Flying()  {
	fmt.Println(this.Name, " 通过学习会飞翔")
}

func (this *LittleMonkey) Swimming()  {
	fmt.Println(this.Name, " 通过学习会游泳")
}

func main()  {

	monkey := LittleMonkey{
		Monkey{Name:"悟空"},
	}

	monkey.climbTree()
	monkey.Flying()
	monkey.Swimming()

}

接口比继承更加灵活，继承是满足 is a 的关系，而接口只需满足 like a 的关系。

多态

变量(实例)具有多种形态。这里给出个判断变量类型的实例，来了解多态。

package main

import "fmt"

type Student struct {
	Name string
	Score float64
}

func JudgeType(items ...interface{})  {
	for index, x := range items {
		switch x.(type) {
			case bool :
				fmt.Printf("第 %v 个参数是 bool 类型，值是 %v \n", index, x)
			case float32 :
				fmt.Printf("第 %v 个参数是 float32 类型，值是 %v \n", index, x)
			case float64 :
				fmt.Printf("第 %v 个参数是 float64 类型，值是 %v \n", index, x)
			case byte:
				fmt.Printf("第 %v 个参数是 byte 类型，值是 %v \n", index, x)
			case int, int32, int64:
				fmt.Printf("第 %v 个参数是 整数类型，值是 %v \n", index, x)
			case string:
				fmt.Printf("第 %v 个参数是 string 类型，值是 %v \n", index, x)
			case Student:
				fmt.Printf("第 %v 个参数是 Student 类型，值是 %v \n", index, x)
			case *Student:
				fmt.Printf("第 %v 个参数是 *Student 类型，值是 %v \n", index, x)
			default :
				fmt.Printf("第 %v 个参数是 类型 不确定，值是 %v \n", index, x)
		}
	}
}

func main()  {

	var n1 float32 = 1.1
	var n2 float64 = 1.1
	var n3 int32 = 1
	address := "北京"
	var b byte = 'a'

	s1 := Student{}
	s2 := &Student{}

	JudgeType(n1, n2, n3, address, b, s1, s2)

}

之所以接口可以实现类型断言，是因为在上面接口介绍中，说了一个注意点，那就是空接口 interface{} 没有任何方法，所以所有类型都实现了空接口。

最后再给个实例

package main

import "fmt"

type Usb interface {
	Start()
	Stop()
}

type Phone struct {
	Name string
}

func (p Phone) Start() {
	fmt.Println(p.Name, "手机开始工作")
}

func (p Phone) Stop()  {
	fmt.Println(p.Name, "手机停止工作")
}

func (p Phone) Call() {
	fmt.Println(p.Name, "手机开始打电话")
}

type Camera struct {
	Name string
}

func (c Camera) Start() {
	fmt.Println(c.Name, "相机开始工作")
}

func (c Camera) Stop()  {
	fmt.Println(c.Name, "相机停止工作")
}

type Computer struct {
	Name string
}

// 编写一个方法 working 方法，接收一个 usb 接口类型变量
// 只要是实现了 Usb 接口 (所谓实现 Usb 接口，就是指实现了 Usb 接口声明所有方法)
func (c Computer) Working(usb Usb)  {
	usb.Start()
	if p, ok := usb.(Phone); ok { // 关键点在这
		p.Call()
	}
	usb.Stop()
}

func main()  {

	var computer Computer

	var usb [3]Usb
	usb[0] = Phone{"苹果"}
	usb[1] = Phone{"联想"}
	usb[2] = Camera{"尼康"}

	for _, v := range usb{
		computer.Working(v)
	}

}