Go语言面向对象编程

Go语言的面相对象和主流语言有很大的不同，如Go 语言里是不支持继承，Go语言的接口实现也不太一样

1. 数据和行为的封装

• 数据的封装

  • 定义一个结构体

    type Employee struct {
      Id string
      Name string
      Age string
    }
    

  • 使用实例里的值

    func TestStruck (t *testing.T) {
      //初始化一个结构体
      e := Employee{"1","李比","20"}
      e1 := Employee{Id:"2",Age:"23"}
      //使用new关键字返回一个指向这个结构体的指针，相当于使用了取地址符"&"
      e2 := new(Employee)
      e2.Age = "30"
    }
    

    PS:使用new关键字会返回结构体的指针、使用.就可以直接访问指针指向的结构体内的元素

• 行为的封装

  • 行为（方法）的定义

    在这个例子里，我们任然使用上面已经定义好了的结构体。定义一个结构体的行为只要在这个函数前面

    type Employee struct {
      Id string
      Name string
      Age string
    }
    
    //使用这种方法定义的行为在使用自己（this）的时候会进行值的复制
    func (e Employee) getString() string {
      return e.Id+","+e.Name+","+e.Age
    }
    
    //使用指针传入的话就会避免内存拷贝
    func (e *Employee) getStringPtr() string {
      return e.Id+","+e.Name+","+e.Age
    }
    
    

2. 接口

• 接口的定义和实现一个接口

  //=========接口定义==========
  type Programmer interface {
    writeCode() string
  }
  
  //=========接口实现==========
  type GoProgrammer struct {
    
  } 
  
  func (g *GoProgrammer) writeCode() string {
    return "fmt.println(\"hello world\")"
  }
  
  

  可以看见，Go语言的接口实现完全没有看见依赖。实现接口的结构体只需要拥有和接口一样函数名和函数签名的函数就可以认为他实现了接口

  因为接口的实现是非入侵性的，Go可以实现先定义实例，后面再去提出公共部分

• 接口的使用如下

  func TestInterface(t *testing.T)  {
    var programmer Programmer
    programmer = new(GoProgrammer)
    t.Log(programmer.writeCode())
  }
  

3. 扩展与复用

用于Go不支持继承，因此Go语言的扩展也变成了Go语言里争议最大的部分

• 扩展的实现方式

  //======父类 宠物类======
  type Pat struct {
  
  }
  
  func (p *Pat) speak() {
    fmt.Println("...")
  }
  
  func (p *Pat) speakTo(host string)  {
    p.speak()
    fmt.Println(host)
  }
  
  //======子类 狗🐶=======
  type Dog struct {
    Pat //在这里声明一个“父类“，这个结构体就可以拥有父类的方法
  }
  
  func (d *Dog) speak() {
    fmt.Println("旺！")
  }
  
  
  //======程序入口======
  func TestDog(t *testing.T)  {
    //var p Pat  = new(Dog)
    d := new(Dog)
    d.speakTo("123") // ... \n 123
  }
  

  从上面的程序可以看出，即时使用了内嵌的匿名成员变量来代替继承，但是在程序入口里可以看出，这种做法没有实现向上转型和重载

4. 多态

下面是一个多态的例子

//=========接口定义==========
type Programmer interface {
    writeCode() string
}

//=========接口实现==========
type GoProgrammer struct {

}

func (g *GoProgrammer) writeCode() string {
    return "fmt.println(\"hello world\")"
}

//======新的Programmer类型实现=====
type JavaProgrammer struct {

}

func (j *JavaProgrammer) writeCode() string {
    return "System.out.println(\"hello world\");"
}

//=======一个普通的方法，传入Programmer类型的数据
func work(programmer Programmer)  {
    fmt.Printf("Type:%T,Code:%s\n",programmer,programmer.writeCode())
}

//======程序入口======
func TestPolymorphism(t *testing.T) {
    java := new(JavaProgrammer)
    goo := new(GoProgrammer)
    work(java)
    work(goo)
}

• 空接口interface{}可以表示任何类型（相当于java的Object或C中的void*）

• 接口定义的规范

  • 倾向于把接口定义得越小越好，如果徐需要使用大接口，那么我们使用多个小接口组合而成，下面就是一个组合接口的事例

    type Interface1 interface{
        ...
    }
    
    type Intercace2 interface{
        ...
    }
    
    type BigInterface interface{
        Interface1
        Interface2
    }