Golang 继承

优点

• 代码扩展性强、便于重复利用

嵌套匿名结构体的基本语法

type Goods struct {

Name string

Price float64

}

type Books struct {

Goods

Author string

}

入门使用

package main

import "fmt"

// 定义一个商品结构体
type Goods struct {
    Name  string
    price float64
}

// 定义Goods方法
func (goods *Goods) GetInfo() {
    fmt.Printf("Name=%v,price=%v\n", goods.Name, goods.price)
}

// 定义一个图书结构体
type Books struct {
    Goods         // 嵌入Goods结构体
    Author string // 专属属性
}

// 图书结构体的绑定方法
func (books *Books) Read() {
    fmt.Println("腹有诗书气自华")
}

// 定义一个计算机结构体
type Computer struct {
    Goods        // 嵌入Goods结构体
    Cpu   string // 专属属性
}

func (computer *Computer) Calc() {
    fmt.Println("运算能力无可匹敌")
}

func main() {
    book := Books{}
    book.Goods.Name = "水浒传"
    book.Goods.price = 89.99
    book.Author = "吴承恩"
    book.GetInfo() // 调用继承来的公用方法
    book.Read()    // 调用私有方法

    computer := Computer{}
    computer.Name = "Apple Mac Pro"
    computer.price = 12999.00
    computer.Cpu = "Apple M2"
    computer.GetInfo() // 调用继承来的公用方法
    computer.Calc()    // 调用私有方法
}

特性

• 结构体可以使用嵌套匿名结构体所有的属性、方法，即：首字母大写或小写的字段、方法，都可以使用

• 匿名结构体字段、方法的访问可以简化

• 当结构体和匿名结构体有相同的属性、方法时，编译器会采用就近访问的原则，如希望访问匿名结构体的属性、方法，可以通过匿名结构体名来区分

package main

import "fmt"

type A struct {
    Name string
}

func (a A) Hello() {
    fmt.Println("Name=", a.Name)
}

type B struct {
    A
    Name string // 存在与A结构体一样的属性
}

func main() {
    b := B{}
    b.Name = "宋江"
    b.Hello() // 会输出空，编译器会采用就近访问的原则，找A的Name，所以访问会空
    b.A.Name = "卢俊义"
    b.Hello() // 会输出：卢俊义
}

• 结构体嵌入两个（或多个）匿名结构体，如两个匿名结构体有相同的属性、方法（同时结构体本身没有同名的属性、方法），在访问时，就必须明确指定匿名结构体名字，否则会报错

• 如果一个结构体嵌套了一个有名结构体，这种模式叫组合。如果是组合关系，那么在访问组合结构体的属性、方法时，必须带上结构体的名字

ackage main

import "fmt"

type A struct {
    Name string
}
type B struct {
    Name string
}
type C struct {
    AStruct A
    BStruct B
}

func main() {
    c := C{A{"宋江"}, B{"卢俊义"}}
    fmt.Println(c)
    fmt.Println(c.AStruct.Name)
    fmt.Println(c.BStruct.Name)
}

• 嵌套匿名结构体后，也可以在创建结构体实例时，可以直接指定各个匿名结构体属性的值

package main

import "fmt"

type Goods struct {
    Name  string
    Price float64
}
type Brand struct {
    Name    string
    Address string
}
type Computer struct {
    GoodStruct  Goods
    BrandStruct Brand
}
type Computer2 struct {
    *Goods
    *Brand
}

func main() {
    // 定义方式一
    computer := Computer{}
    computer.GoodStruct.Name = "Apple Mac Pro"
    computer.GoodStruct.Price = 12999.99
    computer.BrandStruct.Name = "Apple"
    computer.BrandStruct.Address = "USA"
    fmt.Println(computer)
    // 定义方式二
    computer2 := Computer{
        Goods{"Apple Mac Pro~", 13999.99},
        Brand{"Apple~", "USA~"},
    }
    fmt.Println(computer2)
    // 定义方式三（推荐）
    computer3 := Computer{
        Goods{
            Name:  "Apple Mac Pro~~",
            Price: 14999.99,
        },
        Brand{
            Name:    "Apple~~",
            Address: "USA~~",
        },
    }
    fmt.Println(computer3)
    // 指针结构体
    computer4 := Computer2{
        &Goods{
            Name:  "Apple Mac Pro~~~",
            Price: 15999.99,
        },
        &Brand{
            Name:    "Apple~~~",
            Address: "USA~~~",
        },
    }
    fmt.Println(computer4)
    fmt.Println(*computer4.Goods)
    fmt.Println(*&computer4.Goods.Name)
    fmt.Println(*computer4.Brand)
    fmt.Println(*&computer4.Brand.Name)
}