【Go 精选】基本语法

1.如何利用结构体实现继承

package inheritance

import "fmt"

type Pet struct {
    name string
    age  int
}

func (p *Pet) ShowA() {
    fmt.Printf("name is %s, age is %d\n", p.name, p.age)
}

func (p *Pet) ShowB() {
    fmt.Println("能文能武的宠物")
}

type Dog struct {
    Pet
}

func (dog *Dog) ShowB() {
    fmt.Println("自带导航汪汪汪")
}

DogPetShowB()

package inheritance

import "testing"

func TestAnimal(t *testing.T) {
    pet := &Pet{"name1", 1}
    pet.ShowA()
    pet.ShowB()

    dog := new(Dog)
    dog.name = "name2"
    dog.age = 2
    dog.ShowA()
    dog.ShowB()
}

2.如何使用接口

① 不需要显式声明实现了某个接口
② 多个类型可以实现同一个接口
③ 一个类型可以实现多个接口

package interfaces

type Shaper interface {
    SetSide(side float32)
    Area() float32
}

type Square struct {
    side float32
}

func (sq *Square) SetSide(side float32) {
    sq.side = side
}

func (sq *Square) Area() float32 {
    return sq.side * sq.side
}

SquareShaper

package interfaces

func TestInterfaces(t *testing.T) {
    var shaper Shaper
    shaper = new(Square)
    shaper.SetSide(2)
    fmt.Printf("The square has area: %f\n", shaper.Area())
}

3.实战继承和接口 —— 工厂模式

package factorymethod

// Operator 是被封装的实际类接口
type Operator interface {
    SetA(int)
    SetB(int)
    Result() int
}

// OperatorBase 是Operator 接口实现的基类，封装公用方法
type OperatorBase struct {
    a, b int
}

// SetA 设置 A
func (o *OperatorBase) SetA(a int) {
    o.a = a
}

// SetB 设置 B
func (o *OperatorBase) SetB(b int) {
    o.b = b
}

// PlusOperator Operator 的实际加法实现
// 结构体嵌套实现“继承”
type PlusOperator struct {
    OperatorBase
}

func (o *PlusOperator) Result() int {
    return o.a + o.b
}

// OperatorFactory 是工厂接口
type OperatorFactory interface {
    Create() Operator
}

// PlusOperatorFactory 是 PlusOperator 的工厂类
type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Create() Operator {
    return &PlusOperator{OperatorBase{}}
}

// MinusOperator Operator 的实际减法实现
type MinusOperator struct {
    OperatorBase
}

func (o *MinusOperator) Result() int {
    return o.a - o.b
}

// MinusOperatorFactory 是 PlusOperator 的工厂类
type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Create() Operator {
    return &MinusOperator{OperatorBase{}}
}

package factorymethod

import "testing"

func compute(factory OperatorFactory, a, b int) int {
    op := factory.Create()
    op.SetA(a)
    op.SetB(b)
    return op.Result()
}

func TestOperator(t *testing.T) {
    var (
        factory OperatorFactory
    )

    factory = PlusOperatorFactory{}
    if compute(factory, 1, 2) != 3 {
        t.Fatal("error with factory method pattern")
    }

    factory = MinusOperatorFactory{}
    if compute(factory, 4, 2) != 2 {
        t.Fatal("error with factory method pattern")
    }
}