【Go】面向对象

【Go】面向对象

一、面向对象的三大特征

（一）封装：隐藏对象的属性和实现细节，仅对外提供访问方式

（二）继承：使得子类具有父类的属性和方法或重新定义、追加方法和属性等

（三）多态：不同对象中同种行为的不同实现方式

二、go实现封装

使用 type [name] struct{}可以定义一个结构体，包含任意其他类型。

type parent struct {
   son1 int
   son2 string
   son3 []int
}
func main() {
   p := parent{
      son1: 0,
      son2: "123",
      son3: nil,
   }
   fmt.Println(p)
}

测试结果如下：

{0 123 []}

三、go中实现继承

在go中，并没有class的概念。但可以通过结构体的封装实现继承的效果。

type Animal struct {
   name string
   age int
}

func (a *Animal) eat(){
   fmt.Println(a.name,"eating!")
}

首先，在文件中定义一个结构体Animal，包含name和age属性。拥有eat方法。

type Cat struct {
   *Animal
}

再定义其他的结构体，包含Animal结构或Animal的指针结构（例子中使用指针结构）。这样Cat类型就可以使用Animal结构体的方法和属性。

提示：为什么使用指针？

go中方法会传递值或指针，如果传递的是值，go会拷贝一份值给方法，无法改变结构的值。

func main(){
    //初始化时可以使用key:value的方式，也可以直接按照顺序和类型定义，不需要key:
    /*
    myCat := &Cat{
		&Animal{
			name: "mycat",
			age:  0,
		},
	}
	*/
   myCat := &Cat{
      Animal:&Animal{
         name: "mycat",
         age:  1},
   }
   myCat.eat()
   fmt.Println("myCat.name:",myCat.name)
   fmt.Println("myCat.age:",myCat.age)
}

测试结果如下：

mycat eating!
myCat.name: mycat
myCat.age: 1

四、go中实现多态

多态是不同对象中同种行为的不同实现方式。

举个例子，a和b同时做某件事c，但是a的效率是b的两倍！因此，c(a)输出了“2*c”，c(b)只输出了“c”。

type Message interface {
   sendMessage()
}

首先定义一个Message接口，接口中声明sendMessage()方法。

type User struct {
   name string
}
type Admin struct {
   name string
   age int
}
func (u User) sendMessage(){
   fmt.Printf("Sending Message From:%s\n",u.name)
}
func (a Admin) sendMessage(){
   fmt.Printf("Sending Message From:%s,%d\n",a.name,a.age)
}

声明两个结构体，分别实现了Message接口。

func sending(m Message){
   m.sendMessage()
}

最后声明一个新的函数，参数为Message接口，函数内调用m.sendMessage()方法

func main(){
   bill := User{name:"user"}
   lisa := Admin{name:"amdin",age:21}
   sending(bill)
   sending(lisa)
}

写好main方法，并进行测试，结果如下：

Sending Message From:user
Sending Message From:amdin,21