第4章：Go语言面向对象编程

第4章：Go语言面向对象编程

4.1 结构体与方法

4.1.1 定义结构体

// 基本结构体定义
type Person struct {
    Name string
    Age  int
}

// 创建结构体实例
func main() {
    p1 := Person{
        Name: "张三",
        Age:  30,
    }
    
    // 匿名实例
    p2 := struct {
        Name string
        Age  int
    }{
        Name: "李四",
        Age:  25,
    }
}

4.1.2 方法定义

// 值接收者方法
func (p Person) Introduce() string {
    return fmt.Sprintf("我是%s，今年%d岁", p.Name, p.Age)
}

// 指针接收者方法
func (p *Person) Birthday() {
    p.Age++
}

func main() {
    p := Person{Name: "张三", Age: 30}
    fmt.Println(p.Introduce())  // 值方法调用
    p.Birthday()                // 指针方法调用
}

4.2 封装

4.2.1 访问控制

// 大写字母开头：公开
type Student struct {
    Name string  // 公开字段
    age  int     // 私有字段
}

// 私有方法
func (s *Student) calculateGrade() float64 {
    // 内部计算逻辑
    return 0.0
}

// 公开方法
func (s *Student) GetGrade() float64 {
    return s.calculateGrade()
}

4.3 继承与组合

4.3.1 结构体嵌套

type Contact struct {
    Phone string
    Email string
}

type Employee struct {
    Person    // 匿名嵌套
    Contact   // 多重嵌套
    Position  string
}

func main() {
    emp := Employee{
        Person:   Person{Name: "张三", Age: 30},
        Contact:  Contact{Phone: "13800138000"},
        Position: "工程师",
    }
    
    // 直接访问嵌套字段
    fmt.Println(emp.Name)        // 来自Person
    fmt.Println(emp.Phone)       // 来自Contact
}

4.3.2 接口实现

type Swimmer interface {
    Swim() string
}

type Person struct {
    Name string
}

func (p Person) Swim() string {
    return fmt.Sprintf("%s正在游泳", p.Name)
}

func main() {
    var s Swimmer = Person{Name: "张三"}
    fmt.Println(s.Swim())
}

4.4 多态

4.4.1 接口多态

type Shape interface {
    Area() float64
}

type Rectangle struct {
    Width, Height float64
}

type Circle struct {
    Radius float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func PrintArea(s Shape) {
    fmt.Printf("面积：%.2f\n", s.Area())
}

func main() {
    r := Rectangle{Width: 5, Height: 3}
    c := Circle{Radius: 4}
    
    PrintArea(r)  // 多态调用
    PrintArea(c)
}

4.5 接口高级特性

4.5.1 接口组合

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

4.5.2 空接口

func PrintAnything(v interface{}) {
    fmt.Println(v)
}

func main() {
    PrintAnything(42)
    PrintAnything("Hello")
    PrintAnything([]int{1, 2, 3})
}

实践项目：简单的图书管理系统

type Book struct {
    Title  string
    Author string
    Price  float64
}

type Library struct {
    Books []Book
}

func (l *Library) AddBook(book Book) {
    l.Books = append(l.Books, book)
}

func (l *Library) FindBookByTitle(title string) *Book {
    for _, book := range l.Books {
        if book.Title == title {
            return &book
        }
    }
    return nil
}

func main() {
    library := &Library{}
    
    library.AddBook(Book{
        Title:  "Go语言编程",
        Author: "某某",
        Price:  59.9,
    })
    
    book := library.FindBookByTitle("Go语言编程")
    if book != nil {
        fmt.Println(book.Title, book.Author)
    }
}