Golang语言基础篇实现面向对象编程

利用Golang实现面向对象三大特性：封装、继承、多态

 本篇文章除了讨论Golang中实现面向对象的封装、继承、多态外还将讨论接口、方法重写等实现、

一、封装（模版骨架）

封装就是把抽象出的字段和对字段的操作封装在一起，数据被保护在内部，程序的其他包只有通过被授权的操作才能对字段进行操作。

注意：GO开发中并没有特别强调封装，这与Java不同，不能总是用Java的语法特性来看待GO，GO本身对面向对象的特性进行了简化。

1）将结构体、字段的首字母小写（private）
2）给结构体所在的包提供一个工厂模式的函数，首字母大写
3）提供一个首字母大写的Set方法，用于对属性判断与赋值
4）提供一个首字母大写的Get方法，用于获取属性的值

type pizza struct {
	name  string
	price int
}
 
func (p *pizza) SetName(name string) {
	p.name = name
}
 
func (p *pizza) GetName() string {
	return (*p).name
}
 
func (p *pizza) SetPrice(price int) {
	p.price = price
}
 
func (p *pizza) GetPrice() int {
	return (*p).price
}
 
func MakePizza(name string, price int) *pizza {
	return &pizza{
		name:  name,
		price: price,
	}
}


func main() {
	p := pizza.MakePizza("榴莲披萨", 40)
	fmt.Println("我花", p.GetPrice(), "吃到了", p.GetName())
}

二、继承(父子关系)

GO中继承的实现——嵌套匿名结构体，具体代码如下

// 人(父类)
type Person struct {
    name string //姓名
    sex  string //性别
    age  int    //年龄
}

// 学生类(子类)
type Student struct {
    Person     //匿名字段
    class  int //班级
    stuId  int //学号
}

func main() {
    //创建学生对象
    stu := Student{
        Person: Person{name: "小明", sex: "男", age: 18},
        class:  6,
        stuId:  201817340915,
    }
    fmt.Println(stu) // {{小明 男 18} 6 201817340915}
}

不同类指定不同方法

// 人(父类)
type Person struct {
	name string //姓名
	sex  string //性别
	age  int    //年龄
}

// 学生类(子类)
type Student struct {
	Person     //匿名字段
	class  int //班级
	stuId  int //学号
}

// 老师(子类)
type Teacher struct {
	Person         //匿名字段
	subject string //教学科目
	class   int    //班级
}

// 老师-->工作(上班)
func (teacher Teacher) working() {
	fmt.Println(teacher.name + " 正在上班")
}

// 学生-->学习
func (student Student) studying() {
	fmt.Println(student.name + " 正在学习")
}

func main() {
	//创建老师对象
	teacher := Teacher{
		Person:  Person{name: "陈老师", sex: "男", age: 26},
		subject: "体育",
		class:   8,
	}
	//创建学生对象
	student := Student{
		Person: Person{name: "张三", sex: "男", age: 18},
		class:  8,
		stuId:  2018075912,
	}
	teacher.working()  //老师工作  陈老师 正在上班
	student.studying() //学生学习 张三 正在学习

}

三、接口的使用

在go中接口(interface)与结构体一起使用

type Mouse struct {
	name string //鼠标名称
}
type Keyboard struct {
	name string //键盘名称
}

// 接口
type USB interface {
	input()  //输入方法
	output() //输出方法
}

func (mouse Mouse) input() {
	fmt.Println("鼠标输入...")
}

func (mouse Mouse) output() {
	fmt.Println("鼠标输出...")
}

func (keyboard Keyboard) input() {
	fmt.Println("键盘输入...")
}

func (keyboard Keyboard) output() {
	fmt.Println("键盘输出...")
}

func main() {
	//创建鼠标
	mouse := Mouse{
		name: "罗技",
	}
	mouse.input()
	mouse.output()
	keyboard := Keyboard{
		name: "某厂键盘",
	}
	keyboard.input()
	keyboard.output()
}

四、多态(一个事物多种状态)

譬如动物、猫、狗 ：猫和狗是多态的，他们既可以是自己，也可以是动物，这个就是多态，一个事务有多种形念

如下代码为在go中多态的实现

// 动物接口
type Animal interface {
	eat()   //吃
	sleep() //睡
}

type Dog struct {
	name string //狗的名字
}

func (dog Dog) eat() {
	fmt.Println(dog.name + " 正在吃...")
}

func (dog Dog) sleep() {
	fmt.Println(dog.name + " 正在睡...")
}

// 多态方法
func doing(animal Animal) {
	animal.eat()
	animal.sleep()
}

func main() {

	//创建 狗
	dog := Dog{
		name: "小黄",
	}
	doing(dog) //狗属于动物 直接传入
}

五、方法重写

子类可以重写父类的方法
子类还可以新增自己的方法
子类可以访问呢父类中的属性和方法

// 人(父类)
type Person struct {
	name string //姓名
	sex  string //性别
	age  int    //年龄
}

// 老师(子类)
type Teacher struct {
	Person         //匿名字段
	subject string //教学科目
	class   int    //班级
}

// 老师-->工作(上班)
func (teacher Teacher) working() {
	fmt.Println(teacher.name + " 正在上班")
}

// 最顶层父类的方法
func (person Person) working() {
	fmt.Println(person.name + ": 工作使我快乐！")
}

func main() {
	//创建老师对象
	teacher := Teacher{
		Person:  Person{name: "陈老师", sex: "男", age: 26},
		subject: "体育",
		class:   8,
	}

	teacher.working() //老师工作
}

六、空接口(可存储任何类型)

不包含任何方法的接口

因此所有的结构体都默认实现了空接口，空接口可以存储任何的类型
interface{} == any 

//空接口
type Empty interface{}

func test(empty Empty) {

}
func main() {
	//可以传入任何类型 类似于Object
	test(1212)
}

//案例 定义一个什么都可以存储的Map
//可以传入任何类型 类似于Object
anyMap := make(map[string]interface{})
anyMap["name"] = 123
anyMap["key"]="nininini"
anyMap["tin"]=3.141596

希望本篇文章对您学习golang语言有所帮助
by 壹影