golang优雅的面向对象

大家都知道，面向对象的3大基本特征：封装，继承，多态。
封装：
封装是指将某事物的属性和行为包装到对象中，这个对象只对外公布需要公开的属性和行为，而这个公布也是可以有选择性的公布给其它对象

go语言的面向对象
go语言仅支持封装，不支持继承和多态。go 语言没有class 只有struct
go 中没有class 概念 因此无法定义类，但是可以把go中结构体看做对象。
结构体中字段为类的属性，结构体的方法看做对象的行为

type Person struct {
	name string
	age  int
	height int
}
func(p Person)Speak(){

}

对于java编程语言来讲如下所示

public class Person {
    private String name;
    private int age;
    private int height;
    
    //Person 对象的行为,Speak 方法
    void Speak(){

    }
}

封装，对于java来讲有4种访问方式:

1. private 表示成员是类中私有的，只有自身可以访问
2. public 表示成员是类中公开的，所有的类都可以访问
3. 无修饰词(firendly) 同一个包内可以访问，访问权限是包级访问权限
4. protected 同一个包内加上子类都可以访问。

封装，对于go来讲只有2种方式：

对于go语言来讲，没有类的概念，只有包的概念，最小访问粒度是包，同意下变量，常量或者函数在一个包下面，是不可以重名的，而且可以相互访问。

对于一个结构体内部的属性和方法或者函数，名字一般采用CamelCase变量命令。

1. 首字母大写，则代表public,属性公开被访问，函数和方法可以被其他包的调用者调用。
2. 首字母小写，则代表private，属性只能在本包内被访问，函数或者方法只能在本包内被调用。

举例说明：
go

package one

type Person struct {
	name string //只能在本包内使用
	Age  int   //可以在外部使用
}
//可以在外部使用
func(p Person)Speak(){

}
//只能在本包内使用
func(p Person)call(){

}

java

public class Person {
    //私有属性name
    private String name;
    //公开属性age
    public int age;
    //Person 对象的行为,speak 方法,
    // 私有方法只能在本类中使用
    private void speak(){
    }
    //Person 对象的行为,call 方法,
    //公开方法，都可以访问
    public void call(){
        
    }
}

继承

什么是继承：
继承是获取子类获取父类的属性和方法，更改父类的属性和方法，给父类添加属性和方法，继承最直观的好处是少些代码，但是需要理清楚各个对象之间的关系。
go中没有继承，java 中则可以通过extends关键字实现继承。但是golang 可以通过组合来实现“继承”。组合（嵌套）（一个结构体嵌套一个有名的结构， 可以被看做是继承），如果嵌套的结构体为多个则可以看做是多重继承
代码展示

package main

import (
	"fmt"
	"reflect"
)

type Animal struct {
	Name string
	Age  int
}
type Person struct {
	 Animal
	Phone interface{} //人有手机鱼没有，继承追加属性
}
type Fish struct {
	Animal
	Scale interface{} // 鱼有鱼鳞人没有，继承追加属性
	Name int           //重写Name,修改类型为Name
}
func main(){
	fish:=Fish{}
	fish.Name=1
	fmt.Println(reflect.TypeOf(fish.Name)) // int 
}

定义一个Animal对象 然后让Animal对象被鱼对象嵌套，让Animal对象被人对象嵌套。可以看作人和鱼都继承Animal，都获取Animal的Name和Age属性，然后可以对人添加手机和对鱼添加鱼鳞的属性，最后可以把鱼的Name属性的类型为int类型。

下面为Animal 定义方法。

package main

import (
	"fmt"
)

type Animal struct {
	Name string
	Age  int
}
//动物的移动方法
func (Animal) Move()  {
	fmt.Println("animal move")
}

type Person struct {
	 Animal
	Phone interface{} //人有手机鱼没有，继承追加属性
}
//继承自Animal 获取move 方法，并且修改为人独有移动方法为走路
func (Person) Move()  {
	fmt.Println("person walk")
}

//添加人独有的Speak()方法
func (Person) Speak()  {
	fmt.Println("speak")
}

type Fish struct {
	Animal
	Scale interface{} // 鱼有鱼鳞人没有，继承追加属性
	Name int           //重写Name,修改类型为Name
}
//继承自Animal 获取move 方法，并且修改move方法为鱼的移动方式游泳
func (Fish) Move()  {
	fmt.Println("Fish animal")
}


func main(){
	fish:=Fish{}
	person:=Person{}
	fish.Move()//Fish animal
	person.Move()//person walk
}

人和鱼获取move方法，然后重写move方法，修改move方法的行为人走路，鱼游泳。补充一句,go没有重载。

多态：在面向对象中，接口的不同实现即为多态。接口是为一系列方法的集合。在golang 接口的定义如下所示，下面就golang多态。

type eat interface {
	Eat()
}

type Person struct {
	 Animal
	Phone interface{} //人有手机鱼没有，继承追加属性
}
func (Person)Eat(){
fmt.Println("eat dinner")
}
func (Fish)Eat(){
	fmt.Println("eat small fish")
}

type Fish struct {
	Animal
	Scale interface{} // 鱼有鱼鳞人没有，继承追加属性
	Name int           //重写Name,修改类型为Name
}

大家会有疑问，golang 中没有
duck typing 动态绑定，但是golang 是编译时就绑定的。