Go语言既不是一个面向过程的语言，也不是面向对象的语言，相对更加灵活，所以更倾向于让开发者考虑如何使用它。 下面我们聊聊Go如何实现面向对象

Go是怎样做到面向对象

通过结构体实现面向对象

首先Go的结构体如下

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

//两种定义方式
variable_name := structure_variable_type {value1, value2...valuen}
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

结构体的使用和C/C++基本类似，这里我们不去讨论，我们看看Go是如何实现面向对象的。 Go是通过将一个方法绑定到一个结构体上来实现面向对象，那个结构体等价于类实现的方法等价于自己的成员方法。下面看一个简单的例子

package main  
import "fmt"  

type User struct {  
    name string  
    id int  
}  
  
func (user *User) sayMsgAndRetId(msg string) int {  
    fmt.Println("id: ", user.id, " name: ", user.name, " say: ", msg)  
    return user.id  
}  
  
func main() {  
    user := User{  
    name: "zhangsan",  
    id: 1,  
    }  
    user.sayMsgAndRetId("hello golang")  
}

这里我们注意第九行，在函数名字前面有一个User结构体指针，当然这里传不传指针和C/C++的解释一样；这里相当于将say函数绑定到结构体上了，结构体可以通过struct_name.say直接使用。

这里实现了多态

package main  
  
import "fmt"  
  
// Humaner 定义一个接口了类型  
type Humaner interface {  
    // 方法只有声明，没有实现,由别的类型（自定义类型）实现  
    sayhi()  
}  
  
type Student struct {  
    name string  
    id int  
}  
  
// Student类型实现了此方法  
func (temp *Student) sayhi() {  
    fmt.Printf("Student[%s,%d]sayhi\n", temp.name, temp.id)  
}  
  
type Teacher struct {  
    addr string  
    group string  
}  
  
// Teacher类型实现了此方法  
func (temp *Teacher) sayhi() {  
    fmt.Printf("Teacher[%s,%s]sayhi\n", temp.addr, temp.group)  
}  
  
type Mystr string  
  
// Mystr 实现了这个方法  
func (temp *Mystr) sayhi() {  
    fmt.Printf("Mystr[%s]sayhi\n", *temp)  
}  
  
// WhoSayHi 定义一个普通函数，函数的参数为接口类型 只有一个函数，可以有不同表现（多态）  
func WhoSayHi(i Humaner) {  
    i.sayhi()  
}  
  
func main() {  
    s := &Student{"mike", 666}  
    t := &Teacher{"bj", "go"}  
    var str Mystr ="hello mike"  

    // 调用同一函数，不同表现，多态，多种形态  
    WhoSayHi(s)      //Student[mike,666]sayhi
    WhoSayHi(t)      //Teacher[bj,go]sayhi
    WhoSayHi(&str)   //Mystr[hello mike]sayhi
}