1. [面向对象概念]
  3.     ：封装
  5.     ：类定义(属性 + 方法)、对象
  7.   ：继承、多态
  9.   ：接口
[封装]

    ：GO 封装，只有包级别封装；一般，一个目录表示一个包，同级别包定义的方法类型都可见

  ：不同包之间的引用，需要 [import 包目录] , 通过包名访问包内可见方法可属性 [包名.属性、包名.方法]

  ：属性方法名，第一个字母大写，导出属性或函数, 包外可以访问

类定义 (属性、方法)


// 常量定义 [包常量]
const ConstLevel = "Level_10"

// 变量定义 [包变量]
var VarLevel = "VarLevel_10"

// 定义学生类
type Student struct {
    // 姓名 [属性]
    name string
    // 年龄 [属性]
    age int
    // 导出 [属性]
    Sex bool
}

// 构造函数 => 创建学生类对象
func NewStudent() *Student {
    return &Student{
        name: "name",
        age:  0,
        Sex:  true,
    }
}

/********** ********** 公共方法 ********* ********/
// 定义设置属性值方法, 必须指针形式传递, 否则设置无效
// 函数方法定义, 只有指针形式是址传递, 所以操作影响传入对象

// 获取姓名
func (this Student) GetName() string {
    return this.name;
}

// 设置姓名
func (this *Student) SetName(name string) {
    this.name = name;
}

// 获取年龄
func (this Student) GetAge() int {
    return this.age;
}

func (this Student) ToString() string {
    return this.string()
}

/********** ********** 私有方法 ********* ********/
func (this Student) string() string {
    return this.name + "," + strconv.Itoa(this.age)
}

对象创建

// 创建学生对象 s
s := d.Student{}

// 创建学生对象 s
s := d.NewStudent()

// 设置属性值
s.SetName("Ming")

// 获取属性值
name := s.GetName()

类继承 [继承及重写]

// 组合实现继承 => 匿名组合

// 01 定义基础类
type Student struct {
    Name string
}

func (s *Student) ReName() {
    fmt.Println("Student.GetName")
}

func (s *Student) PriStu() {
    fmt.Println("Student.PriStu")
}

// 02 定义子类 [继承方法 => GetName, PriStu]
// 结构体HighStudent继承了Student（组合了Student）
type HighStudent struct {
    // 基础类 [继承]
    Student

    //
    Age string
}

// 重写父类方法 = 子类和父类中有相同的属性名，父类的属性名会被屏蔽
// hi.Student.ReName() # 可以显示调用父类方法
func (h *HighStudent) ReName() {
    fmt.Println("HighStudent.GetName")
}

// 子类私有方法
func (h *HighStudent) PriHiStu() {
    fmt.Println("PriHiStu")
}

接口

[接口]

    ：非侵入式接口，类只需要实现了接口要求的所有函数，就说可以认为这个类实现了该接口

  ：接口赋值 => 接口拥有相同的方法列表（次序不同不要紧），那么它们就是等同的，可以相互赋值
    // 接口赋值并不要求两个接口必须等价
    // A是B子集, B可以直接赋值给A; A不能直接赋值给B，需要接口查询才能赋值
        // 查询对象必须实现这个接口的所有方法, 对象.(接口)

    ：接口组合 => 可以直接，组合获取其他接口的定义列表

    ：interface{} => Any类型, 任何对象实例都满足空接口interface{},当作指向任何对象的Any类

// 01 定义接口 IFile
type IFile interface {
    // 定义 接口方法 => Read()、 Write
    Read(buf []byte) (n int, err error)
    Write(buf []byte) (n int, err error)
}

// 01 定义 File 类
type File struct {
    // ...
}

// 实现 接口IFile所有方法 => Read()、Write() 方法
// 该类File实现了该接口IFile
// 即, 该类 可以直接对接口赋值, 及该接口的引用可以指向该类对象
func (f *File) Read(buf []byte) (n int, err error) {
    // 实现接口 IFile.Read() 方法
    fmt.Println("File.Read")
    return
}

func (f *File) Write(buf []byte) (n int, err error) {
    // 实现接口 IFile.Write() 方法
    fmt.Println("File.Write")
    return
}

func (f *File) Close() error {
    // 类一般方法
    fmt.Println("File.Close")
    return nil
}

// 使用
// var f data.IFile = new(data.File)
// f.Write([]byte{10})

// 接口组合
type IRead interface {
    // 定义 接口方法 => Read()
    Read(buf []byte) (n int, err error)
}

type IWrite interface {
    // 定义 接口方法 => Write()
    Write(buf []byte) (n int, err error)
}

// 接口IReadWrite, 组合接口 IRead 和 接口 IWrite
type IReadWrite interface {
    IRead
    IWrite
}

// 等同于
type IReadWrite interface {
    Read(buf []byte) (n int, err error)
    Write(buf []byte) (n int, err error)
}