类
go没有普通的类概念，可以随心所欲的根据自己的喜好来编写自己喜欢的风格
类型系统：
可以在已有类型之上增加新类型
type Integer int
func (a Integer) Less(b Integer) bool(
return a<b
)
也可以新增类型
type Person struct{
name string
}
func (p *Person) say(){
}
func (p *Person) walk(){
}
继承：
继承是使用匿名组合的方法
type Person struct{}
func(p *Person) ShowA(){
p.ShowB()
}
func(p *Person) ShowB(){}
type Teacher struct{
Person
}
func (t *Teacher ) ShowB(){}
func main(){
t:=Teacher()
t.ShowA()
}
这是Golang的组合模式，可以实现OOP的继承。注意，被组合的类型Person虽然升级成了外部类型的方法，但是他们的方法调用时接收者并没有发生变化，此时Person并不知道自己被什么类型组合，所以showA中会调用Person的ShowB
多态：
type mm interface(){ mm() }
type A struct{
}
func (*a A) mm(){}
type B struct{
}
func (*b B) mm(){}
send(m mm){m.mm()}
a:=A{} send(a)
b:B{} send(b)
A的实例和B的实例都可以使用send方法，这是多态的体现
接口：
接口推断：系统可以根据 func (a Integer) Less{}
自动生成func(a *Integer) Less{ (*a).Less(b)}
但是无法根据 func(a *Integer) Less{}自动生成
func (a Integer) Less{(&a).Less() }
原因是&a只会改变函数参数的对象，不会改变实际操作的对象。
闭包
go 存在闭包的特性，这点用法和JS类似
for i:=0;i<10;i++{
go func(){
fmt.PrintLn("A:",i)
}
go func(){
fmt.Println("B:",i)
}(i)
}
A均为10，B是0-9，顺序不定
有意思的是，可以利用go的闭包，模拟私有变量
因为go的命名规则内部小写类似protected ，大写类似public,而类型的私有变量private，可以通过闭包模拟，当然更平常的方式是套上额外的一层结构,即内嵌结构,来使得外界不能覆盖。
如
type File struct{
*file
}
type file struct{
fd int
name string
}