1、建筑结构方式

go并不是纯碎的面向对象编程的，在go里边涵数是一等中国公民，可是go也是建筑结构保持相近java一样类的作用来出示抽象性。建筑结构的方式分成值方式和表针方式，前面一种在方式中做的更改始终不变启用的案例目标，后面一种则会更改，一样无论是值种类還是表针种类全是能够 被启用的，由于go建筑结构最底层会全自动转换

例如下边是一切正常的启用：

type Stu struct {
    name string
}
func (this Stu) SayName()  {
    log.Println(this.name)
}

s:=Stu{"Biningo"}
s.SayName()

假如再界定一个方式

func (this *Stu) ChangeName(name string)  {
    this.name = name
}

由于要更改，因此界定了一个表针种类方式，可是以下启用還是能够 的

s:=Stu{"Biningo"}
s.ChangeName("xxx")  // 会更改

s2:=&Stu{"Biningo"}
s2.ChangeName("xxxx")  //会更改
s2.SayName() //会默认设置转换 等于(*s2).SayName() xxxx

留意，go中不是容许方法重载的。另外无论是值种类方式還是表针种类方式姓名都不容许一样

2、密名特性和承继

承继：

type Camera struct {
    name string
}
type Phone struct{}

func (p *Phone) Call()  {
    fmt.Println("通电话")
}
func (c *Camera) TakePicture()  {
    fmt.Println("拍摄照片")
}

type CameraPhone struct {
    Camera
    Phone
}

承继只必须构造身体嵌一个要承继的建筑结构就就行了，那样就能够 立即应用父类的方式了

phone:=new(CameraPhone)
phone.Call()
phone.TakePicture()

密名特性:

type CameraPhone struct {
    Camera
    Phone
    int
}

人们加了一个int种类，此刻等于加了一个姓名为int，种类为int的特性，姓名和种类名一样

能够 以下应用：

phone:=new(CameraPhone)
phone.Call()
phone.TakePicture()
phone.int=1001

可是留意，密名特性同种类只容许一个

那麼人们允不容许承继组成一个托词种类呢？那自然都是能够 的

下边看一种建筑结构和插口的组成而且保持多态:

type Clothe interface {
    SayColor()
}

type BlueClothe struct {
    Color string
}

func (b *BlueClothe) SayColor()  {
    log.Println("Blue")
}

type RedClothe struct {
    Color string
}

func (b *RedClothe) SayColor()  {
    log.Println("Blue")
}



type Stu struct {
    Clothe
    Name string
}

func main() {
    blue:=&BlueClothe{Color:"Blue"}
    var stu Stu
    stu.Clothe = blue //密名种类姓名就是说种类名
    stu.Name="biningo"
    stu.SayColor()
}

3、建筑结构特性名字矛盾

即然能够 随便承继组成，而且能够 立即由子类启用，那假如承继好几个父类有同样的特性名如何判断呢？以下：

type A struct {
    a,b int
}

type B struct {
    a int
}

上边界定了2个建筑结构，下边承继这2个建筑结构，留意这儿a特性姓名同样

type C struct {A;B}

以下处理矛盾

c:=C{A{1,1},B{2}}
fmt.Println(c.A.a,c.B.a) //c.a出错 必须指出是A還是B的a

你是否还记得密名字段名吧，这儿就等于指出实际特性，启用实际特性的特性

一般密名字段名的方式是能够 立即启用的，密名字段名启用方式的情况下是能够 忽视字段名的，等于是一个简称方式

可是假如2个矛盾字段名深层不一样呢？那便是浅的遮盖深的特性