5.Go-封裝、繼承、接口、多態和斷言

面向對象

Go語言開發者認為：面向對象就是特定類型（結構體）有着自己的方法，利用這個方法完成面向對象編程，

並沒有提封裝、繼承、多態。所以Go語言進行面向對象編程時，重點在於靈活使用方法。

Go語言有着自己對面向對象的理解，它也有着自己的封裝、繼承、多態。

5.1.封裝

實例

//Learn_Go/main.go
package main

import (
	"fmt"
)

type People struct {
	name string
	age int
}

func (p *People) SetName(name string)  {
	p.name = name
}

func (p *People) SetAge(age int)  {
	p.age = age
}

func (p *People) GetName() string{
	return p.name
}

func (p *People) GetAge() int{
	return p.age
}

func main()  {
	peo := new(People)
	peo.SetName("derek")
	peo.SetAge(22)
	fmt.Println(peo.GetName(),peo.GetAge())     //derek 22
}

5.2.繼承

//Learn_Go/main.go
package main

import "fmt"

type People struct {
	name string
	age int
}

type Teacher struct {
	People
	classroom string
}

func main()  {
	tea := Teacher{People{"derek",22},"911"}
	fmt.Println(tea.classroom,tea.name,tea.age)    //911 derek 22
}

5.3.接口

接口是一組行為規范的定義

接口中只能有方法聲明，方法只能有名次、參數、返回值，不能有方法體

每個接口中可以有多個方法，結構體把接口總所有方法都重寫后，結構體就屬於接口類型

Go語言中接口和結構體之間的關系是傳統面向對象中is-like-a的關系

//Learn_Go/main.go
package main

import "fmt"

type Live interface {
	run(i int)
	eat(thing string)
}

type People struct {
	name string
}

func (p *People) run(i int)  {
	fmt.Println(p.name,"跑了",i,"米")
}

func (p *People) eat(thing string)  {
	fmt.Println(p.name,"正在吃",thing)
}

func main()  {
	peo := People{"derek"}
	peo.run(100)
	peo.eat("面包")
}

5.4.多態　　

多態：同一件事情由於條件不同產生的結果不同

由於go語言中結構體不能相互轉換，所以沒有結構體的多態，只有基於接口的多態

//Learn_Go/main.go
package main

import "fmt"

type Live interface {
	run()
}

type People struct {
	name string
}

type Animal struct {
	name string
}

func (p *People) run()  {
	fmt.Printf("%v在跑步",p.name)
}

func (a *Animal) run()  {
	fmt.Printf("%v在跑步",a.name)
}

func allrun(live Live)  {
	live.run()
}

func main()  {
	//接口不能實例化，只能對接口的結構體實例化
	peo := &People{"derek"}
	allrun(peo)      //derek在跑步
	//多態，條件不同結果不同
	a := &Animal{"小狗"}
	allrun(a)       //小狗在跑步
}

5.5.斷言

只要實現了接口的全部方法認為這個類型屬於接口類型，如果編寫一個接口，這個接口沒有任何

方法，這是認為所有類型都是了這個接口，所以Go語言中interface{}代表任意類型

如果interface{]作為方法參數就可以接受任意類型，但是在程序中有時有需要知道這個參數

到底是什么類型，這個時候就需要使用斷言

（1）斷言可以有一個返回值，如果判斷結果是指定類型返回變量值，否則報錯

//Learn_Go/main.go
package main

import "fmt"

func main()  {
	var i interface{} = 44     //i是int類型
	result1 := i.(int)
	fmt.Println(result1)     //44

	result2 := i.(string)
	fmt.Println(result2)    //panic: interface conversion: interface {} is int, not string
}

（2）可以查看值的類型　

//Learn_Go/main.go
package main

import "fmt"

func main()  {
	var i interface{} = 44     //i是int類型
	result,ok := i.(int)
	fmt.Println(result,ok)     //44 true
	fmt.Printf("%T",result)    //int
}   

（3）通過斷言判斷值的類型

//Learn_Go/main.go
package main

import "fmt"

func demo(i interface{})  {
	_,ok := i.(int)
	if ok{
		fmt.Println("參是int類型")
		return
	}
	_,ok = i.(string)
	if ok{
		fmt.Println("參是string類型")
		return
	}
	fmt.Println("參數類型不確定，不是int和string類型")
}

func main()  {
	demo(8)            //參是int類型
	demo("derek")      //參是string類型
	demo(3.146)        //參數類型不確定，不是int和string類型
}