封裝

go中的封裝和java的不太一樣，在go裡面是沒有java中的class，不過可以把struct看成一個類，封裝可以簡單地看作對struct的封裝，對應封裝struct的方法。

type obj1 struct {
    valte1 string
}
type obj2 struct {
    valte2 string
}

繼承

把struct看做類，struct中可以包含其他的struct，繼承內部struct的方法和變數，同時可以重寫。

package main

import "fmt"

type oo struct {
    inner
    ss1 string
 

    ss2 int
    ss3 bool
}

type inner struct {
    ss4 string
}

func (i *inner) testMethod(){
    fmt.Println("testMethod is called!!!")
}

func main()  {
    oo1 := new(oo)
    fmt.Println("ss4無值："+oo1.ss4)
    oo1.ss4 = "abc"
    fmt.Println("ss4已賦值"+oo1.ss4)
    oo1.testMethod() //繼承呼叫inner對應的方法
 

    oo1.inner.testMethod()//繼承呼叫 這裡也可以重寫
}

多型

go中的多型比java的隱匿得多，嚴格上說沒有多型，但可以利用介面進行，對於都實現了同一介面的兩種物件，可以進行類似地向上轉型，並且在此時可以對方法進行多型路由分發。

package main

import "fmt"

type interfacetest interface {
    //testMothod1() string
    //testMothod()//這種會報語法錯誤 在go裡面是不允許的
    iMethod() //加上int則會報錯 說明go的方法判斷有返回值，而java沒有 
 

}

type obj1 struct {
    valte1 string
}

type obj2 struct {
    valte2 string
}

//從屬不同物件的testMothod 返回值不同的介面實現
func ( obj11 *obj1)iMethod(){
    fmt.Println("testMothod go obj1")
}

//從屬不同物件的testMothod 返回值不同的介面實現
func ( obj11 *obj2)iMethod() {
    fmt.Println("testMothod go obj2")
}


func gorun(ii interfacetest){
    fmt.Println(ii.iMethod)
}

func main(){
    var i interfacetest
    //interfacetest_ := new(interfacetest)//這種方式進行多臺路由轉發會報錯 GO需先宣告 如 var i interfacetest
    obj1_ := new(obj1)
    //賦obj1
    i = obj1_
    i.iMethod()//正確列印
    gorun(i)
    gorun(obj1_)
    //interfacetest_.testMethod() //這種在java中允許，在go中是不允許的
    //賦obj2
    obj2_ := new(obj2)
    i = obj2_
    i.iMethod()//正確列印
    gorun(i)
    gorun(obj2_)
    list := [2]interfacetest{obj1_,obj2_}

    slice := []interfacetest{}
    slice = append(slice, obj1_)
    slice = append(slice, obj2_)
    for index,value := range slice {
        fmt.Println(index)
        fmt.Println(value)
    }
    fmt.Println(len(slice))

    fmt.Println(len(list))
}