结构体嵌套 #

type Address struct {
    City    string
    Country string
}

type Person struct {
    Name    string
    Address Address
}

p := Person{
    Name: "Alice",
    Address: Address{
        City:    "Beijing",
        Country: "China",
    },
}

fmt.Println(p.Address.City)  // Beijing

p.Address.City = "Shanghai"
fmt.Println(p.Address.City)

type Person struct {
    Name string
    Address  // 匿名嵌入
}

p := Person{
    Name: "Alice",
    Address: Address{
        City: "Beijing",
    },
}

fmt.Println(p.City)  // Beijing（字段提升）
fmt.Println(p.Address.City)  // Beijing

type Inner struct {
    X int
}

type Outer struct {
    Inner
    Y int
}

o := Outer{Inner: Inner{X: 10}, Y: 20}
fmt.Println(o.X)      // 10（提升）
fmt.Println(o.Inner.X) // 10
fmt.Println(o.Y)      // 20

type MySlice []int

func (s MySlice) Sum() int {
    sum := 0
    for _, v := range s {
        sum += v
    }
    return sum
}

type Data struct {
    MySlice
}

d := Data{MySlice: MySlice{1, 2, 3}}
fmt.Println(d.Sum())     // 3
fmt.Println(d.MySlice.Sum())  // 3

type Animal struct {
    Name string
}

func (a Animal) Speak() {
    fmt.Println("Some sound")
}

type Dog struct {
    Animal
}

func main() {
    d := Dog{Animal{Name: "Buddy"}}
    d.Speak()  // Some sound
}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

func main() {
    d := Dog{Animal{Name: "Buddy"}}
    d.Speak()          // Woof!
    d.Animal.Speak()   // Some sound
}

type Base struct{}

func (b Base) Method1() {
    fmt.Println("Base.Method1")
}

type Middle struct {
    Base
}

func (m Middle) Method2() {
    fmt.Println("Middle.Method2")
}

type Derived struct {
    Middle
}

func main() {
    d := Derived{}
    d.Method1()  // Base.Method1
    d.Method2()  // Middle.Method2
}

type A struct {
    X int
}

type B struct {
    X int
}

type C struct {
    A
    B
}

c := C{A: A{X: 1}, B: B{X: 2}}
// fmt.Println(c.X)  // 错误：歧义
fmt.Println(c.A.X)  // 1
fmt.Println(c.B.X)  // 2

type Inner struct {
    X int
}

type Outer struct {
    Inner
    X int  // 覆盖Inner.X
}

o := Outer{Inner: Inner{X: 1}, X: 2}
fmt.Println(o.X)      // 2（外层）
fmt.Println(o.Inner.X) // 1

type Person struct {
    Name string
    Address *Address
}

p := Person{
    Name: "Alice",
    Address: &Address{
        City: "Beijing",
    },
}

fmt.Println(p.City)  // Beijing

type Person struct {
    Address *Address
}

func (p Person) GetCity() string {
    if p.Address == nil {
        return "Unknown"
    }
    return p.Address.City
}

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

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

type ReadWriter struct {
    Reader
    Writer
}

type Logger struct {
    prefix string
}

func (l Logger) Log(msg string) {
    fmt.Printf("[%s] %s\n", l.prefix, msg)
}

type Service struct {
    Logger
    name string
}

func main() {
    s := Service{
        Logger: Logger{prefix: "INFO"},
        name:   "MyService",
    }
    s.Log("Service started")
}

type Reader interface {
    Read() string
}

type Writer interface {
    Write(string)
}

type ReadWriter interface {
    Reader
    Writer
}

type Handler struct {
    http.Handler
}

func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Before")
    h.Handler.ServeHTTP(w, r)
    fmt.Println("After")
}

type DataSource interface {
    Read() string
}

type FileSource struct {
    content string
}

func (f *FileSource) Read() string {
    return f.content
}

type CachedSource struct {
    DataSource
    cache string
}

func (c *CachedSource) Read() string {
    if c.cache == "" {
        c.cache = c.DataSource.Read()
    }
    return c.cache
}

type Handler struct {
    next http.Handler
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Middleware before")
    h.next.ServeHTTP(w, r)
    fmt.Println("Middleware after")
}

type Timestamp struct {
    CreatedAt time.Time
    UpdatedAt time.Time
}

func (t *Timestamp) Touch() {
    t.UpdatedAt = time.Now()
}

type User struct {
    ID   int
    Name string
    Timestamp
}

type Article struct {
    ID    int
    Title string
    Timestamp
}

// 好：组合
type Service struct {
    Logger
    DB
}

// 避免：深层嵌套
type A struct { B }
type B struct { C }
type C struct { D }

// 简单清晰
type User struct {
    Name    string
    Address Address
}

// 过度嵌套
type User struct {
    Profile struct {
        Basic struct {
            Name string
        }
    }
}

type Person struct {
    Name string
    Address
}

p := Person{}
p.City = "Beijing"      // 清晰
p.Address.City = "Beijing"  // 更明确