go 封装继承多态

1. 封装性（Encapsulation）：Go 语言通过大小写控制访问权限，大写开头的字段和方法可以被外部包访问，小写开头的字段和方法只能被本包访问。这样可以实现封装性，使得外部无法直接访问对象内部的状态和行为，需要通过提供的接口进行操作。

package main

import "fmt"

type Person struct {
    name   string
    age    int
    gender string
}

func (p *Person) SetName(name string) {
    p.name = name
}

func (p *Person) GetName() string {
    return p.name
}

func main() {
    p := &Person{name: "Tom", age: 18, gender: "Male"}
    p.SetName("Jack")
    fmt.Printf("The person's name is %s.\n", p.GetName())
}

3. 继承性（Inheritance）：Go 语言没有提供传统意义上的继承，但是通过嵌入结构体的方式可以实现类似的功能。子结构体可以访问父结构体中的字段和方法，实现了代码的复用。

package main

import "fmt"

type Animal struct {
    name string
}

func (a *Animal) Eat() {
    fmt.Printf("%s is eating.\n", a.name)
}

type Cat struct {
    Animal
}

func main() {
    c := &Cat{Animal{name: "Tom"}}
    c.Eat()
}

5. 多态性（Polymorphism）：Go 语言通过接口实现多态性。接口是一组方法签名的集合，一个类型只要实现了接口中的所有方法，就可以被认为是这个接口类型。不同类型实现同一个接口的方法可以有不同的实现方式，实现了多态性。

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    radius float64
}

func (c *Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

type Rectangle struct {
    width  float64
    height float64
}

func (r *Rectangle) Area() float64 {
    return r.width * r.height
}

func main() {
    var s Shape
    c := &Circle{radius: 5}
    s = c
    fmt.Printf("The circle's area is %.2f.\n", s.Area())

    r := &Rectangle{width: 3, height: 4}
    s = r
    fmt.Printf("The rectangle's area is %.2f.\n", s.Area())
}