go面向对象的理解

在go语言中没有面向对象的概念，但是可以通过下面方式实现面向对象的特征

• 封装， 通过方法实现
• 继承， 通过匿名字段实现
• 多态， 通过接口实现

方法

方法定义

// 定义方法
type Mystr string
func (temp *Mystr) Hello() {
    fmt.Println("Mystr = ", *temp)
}

func main(){
    var a Mystr
    a.Hello() // 方法使用
}

匿名字段

匿名字段定义

type Person struct {
    name string
    id   int
}

// 继承
type Student struct {
    Person
    addr string
}

匿名字段初始化

func main() {
    // 第一种方式初始化
    var a Student
    a.Person = new(Person)  // 必须先分配空间，才能给父类赋值
    a.name = "xiaoming"

    // 第二种初始化
    s := Student{Person{"xiaoming", 122}, "qwjh"}

    // 第三种初始化，指定某个元素初始化
    var d Student = Student{Person:Person{name: "xiaomi"},addr: "ni"}
}

接口

• 方法的集合

接口定义

// 定义接口类型接口
type Humer interface {
    // 方法，只有声明，没有实现
    Hello()
}

// 定义方法
type Mystr string
func (temp *Mystr) Hello() {
    fmt.Println("Mystr = ", *temp)
}

func main() {
    // 定义接口类型变量
    var i Humer
    var a Mystr = "lakalk"
    i = a  // 将类型a赋值给接口
    i.Hello() // 调用函数，Mystr = lakalk
}

• 接口存在继承，被继承的接口，称为子集， 继承的接口，称为超集
• 超集可以转换为子集，但子集不能转换为超集

// 定义接口类型接口
type Humer interface {
    // 方法，只有声明，没有实现
    Hello()
}

// 继承Humer接口
type Personer interface {
    // 匿名字段
    Humer
}

// 定义方法
type Mystr string
func (temp *Mystr) Hello() {
    fmt.Println("Mystr = ", *temp)
}

func main() {
    // 定义接口类型变量
    var i Humer
    var j Personer
    var a Mystr = "lakalk"
    i = a  // 将类型a赋值给接口
    i = j // 将超集转换为子集
    i.Hello() // 调用函数，Mystr = lakalk
}

空接口

• 可以保存任何的值

// 定义空接口
var i interface{}

// 一般空接口可用在函数接收不定参数
func xxx(arg ...interface) {
    for _, i := range arg {
        if value,ok := i.(int); ok == true {
            fmt.Printf("整型%T, %v\n", i, value)
        } else if value,ok := i.(string); ok == true {
            fmt.Printf("字符串%T, %v\n", i, value)
        }   
    }
}