go语言-面向对象编程

luckyFang 2021年03月15日 85次浏览

type

给类型起别名 相当于 C的typedef

package main

import "fmt"

func main() {
	// 给类型起别名
	// type 类型名 类型
	type INT int

	var a INT
	fmt.Println(a)
}

定义结构体

package main

import "fmt"

type Person struct {
	name string
	age int
}


func main() {
	var p Person
	p.name="JackMa"
	p.age=56

	fmt.Printf("%+v",p)
}

{name:JackMa age:56}

封装

package main

import "fmt"

type Person struct {
	name string
	age int
}

// 当前this是对象的拷贝
func (this Person)print()  {
	fmt.Printf("%#v\n",this)
}
// 如果需要修改值则需要指针

func (this *Person)setValue(name string)  {
	this.name=name
}

func main() {
	var p Person
	p.name="JackMa"
	p.age=56

	fmt.Printf("%+v\n",p)
	p.print()
	p.setValue("aaaa")
	p.print()
}

{name:JackMa age:56}
main.Person{name:"JackMa", age:56}
main.Person{name:"aaaa", age:56}

继承

package main

import (
	"fmt"
	"reflect"
)

type Animal struct {
}

func (this *Animal)Eat()  {
	fmt.Printf("Obj:%v Eat\n",reflect.TypeOf(this))

}
func (this *Animal)Drink()  {
	fmt.Printf("Obj:%v Drink\n",reflect.TypeOf(this))

}

type Dog struct {
	// 自动继承 Animal的所有方法
	Animal
}

// 重写父类方法

func (this *Dog)Eat()  {
	fmt.Printf("Obj:%v Eat\n",reflect.TypeOf(this))
}



func main() {
	// 创建一个子类对象
	dog :=Dog{Animal{}}
	// 子类方法
	dog.Eat()
	// 父类方法
	dog.Drink()
}

Obj:*main.Dog Eat
Obj:*main.Animal Drink

多态

  • 接口本质上就是一个指针
  • 如果一个类包含接口的所有方法则默认实现该接口
  • 使用接口实现多态(父对象指针指向子对象)
package main

import (
	"fmt"
	"reflect"
)

// 定义一个接口
type Pen interface {
	Write()
	GetColor() string
}

// 一个类实现 interface 中所有方法则自动实现这个接口
type Pencil struct {
	color string
}

func (this *Pencil) GetColor() string {
	return this.color
}

func (this *Pencil) Write() {
	fmt.Printf("Obj:%v Write\n", reflect.TypeOf(this))
}

// 一个类实现 interface 中所有方法则自动实现这个接口
type Chalk struct {
	color string
}

func (this *Chalk) GetColor() string {
	return this.color
}

func (this *Chalk) Write() {
	fmt.Printf("Obj:%v Write\n", reflect.TypeOf(this))
}

func write(pen Pen) {
	pen.Write()
}

func main() {
	/*
		// 父类接口 本质上是一个指针
		var pen Pen
		pen= &Pencil{"red"}
		write(pen)
		write(&Chalk{"white"})
	*/

	pencil:=Pencil{"red"}
	chalk:=Chalk{"white"}
	write(&pencil)
	write(&chalk)
}

Obj:*main.Pencil Write
Obj:*main.Chalk Write