golang面向对象三大基本特征

面向对象的三大基本特征：

1. 封装：仅对外提供公共访问方式，隐藏对象的属性和实现细节
2. 继承：子类具有父类的属性和方法或者追加属性和方法等
3. 多态：不同对象针对同种行为(方法)的不同实现

封装

Go 语言中通过结构体进行封装

Go 方法是结构体的函数

package main

import (
	"fmt"
)

// 矩形结构体
type Rectangle struct {
	Length int
	Width  int
}

// 计算矩形面积
func (r *Rectangle) Area() int {
	return r.Length * r.Width
}

func main() {
	r := Rectangle{4, 2}
	// 调用 Area() 方法，计算面积
	fmt.Println(r.Area())
}

修改结构的属性值

package main

import (
	"fmt"
)

type Person struct {
	name string
	sex  string
	age  int
}

func (p *Person) SetInfo(name string, sex string, age int) *Person {
	p.name = name
	p.sex = sex
	p.age = age
	return &Person{}
}
func (p *Person) SetSexInfo(sex string) *Person {
	p.sex = sex
	return &Person{}
}
func main() {
	p := Person{"周挺", "男", 18}
	p.SetInfo("周挺", "女", 18)
	fmt.Printf("整体修改有些是没必要打的:%v\n", p)
	p.SetSexInfo("男")
	fmt.Printf("局部修改后:%v\n", p)
}

继承

方法重写

子类可以复用父类方法，也可以重写

重写就是在子类中把继承自父类的某个方法重新写一遍。这样就能在子类中弄出一个同名的、更适合自身或者是效率更高的方法。

package main

import (
	"fmt"
)

type Engine interface {
	Start()
	Stop()
}

type Car struct {
	Engine // 包含 Engine 类型的匿名字段
}

func (c *Car) GoToWorkIn() {
	c.Start()
	c.Stop()
}
func (c *Car) Start() {
	fmt.Println("get in car")
}
func (c *Car) Stop() {
	fmt.Println("get out of car")
}
func main() {
	c := new(Car)
	c.GoToWorkIn()
}

多态

Go 语言使用接口实现多态

package main

import (
	"fmt"
)

// 接口 Shaper
type Shaper interface {
	Area() float32
}

// 正方形
type Square struct {
	side float32
}

// 长方形
type Rectangle struct {
	length, width float32
}

// 计算正方形的面积
func (sq Square) Area() float32 {
	return sq.side * sq.side
}

// 计算长方形的面积
func (r Rectangle) Area() float32 {
	return r.length * r.width
}

func main() {
	r := Rectangle{10, 2}
	q := Square{10}

	// 创建一个 Shaper 类型的数组
	shapes := []Shaper{r, q}
	// 迭代数组上的每一个元素并调用 Area() 方法
	for n, _ := range shapes {

		fmt.Printf("图形数据:%#v ", shapes[n])
		fmt.Println("它的面积是: ", shapes[n].Area())
	}
}