go的面向对象编程

package base

import "fmt"

//面向对象编程，一般的面向对象编程有三种特性，封装继承多态
//go的多态
/*封装：通过方法实现
继承：通过匿名函数实现
多态：通过接口实现*/

//匿名组合，
type Person struct {
    name string
    sex  string
    age  int
}
type Student struct {
    Person //只有类型，没有名字，匿名字段，继承了person的成员
    id     int
    addr   string
}
type Student1 struct {
    Person //只有类型，没有名字，匿名字段，继承了person的成员
    id     int
    addr   string
    name   string //同名字段
}

type Student2 struct {
    *Person //指针类型，没有名字，匿名字段，继承了person的成员
    id      int
    addr    string
    name    string //同名字段
}

//使用匿名组合
func DefinStudent() {

    //使用person时要加上person
    s1 := Student{Person{"xiaoqin", "m", 10}, 1, "**jie"}
    //%+v显示信息更完整
    fmt.Printf("s1=%+v\n", s1)

    //成员的操作,直接使用Person里面的结构成员就行
    fmt.Println(s1.name, s1.id, s1.addr)

    //同名字段，默认规则，就近原则，在最近的结构体类寻找
    var s2 Student1
    s2.name = "xiaohong" //默认给Student1下的name赋值

    //显示调用
    s2.Person.name = "honghong"

    //对含指针的匿名字段赋值
    s3 := Student2{&Person{"xiaohong", "男", 10}, 123, "**jie", "guug"}

    fmt.Printf("s3=%+v\n", s3)

    //第二种方式赋值
    var s4 Student2
    s4.Person = new(Person) //分配空间
    s4.Person.name = "xiaohong"
    fmt.Printf("s4=%+v\n", s4)
}

//方法func (*** type) MethionName(){} ***是接收者

//面向对象和面向过程函数区别
//面向过程
func Add01(a, b int) int {
    return a + b
}

//面向对象，方法给某个类型绑定一个函数
type long int

//tmp叫接收者，接收者是传递的一个参数，接收者本身不能是指针
func (tmp long) Add02(other long) long {
    return tmp + other
}

//接收者本身不能是指针
func (tmp *long) Add03() {
}

//接收者本身不能是指针
//type long1 *int
//func (tmp long1) Add03() {
//}

//接收者不一样，及时方法名一样，他也是不同的方法
type char byte
func (tmp char) Add02(other char) char {
    return tmp + other
}
func OneFun() {
    //面向过程调用
    result := Add01(1, 1)
    fmt.Println("result= ", result)

    //面向对象调用
    var a long = 2
    result1 := a.Add02(3)
    fmt.Println("result1= ", result1)
}

//结构体函数添加方法

//值语义（一份拷贝）和引用语义（指针传递）

//方法继承