##封装
go中的封装和java的不太一样，在go里面是没有java中的class，不过可以把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()//继承调用
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))
}
```
