Struct embedding (composition) hoạt động như thế nào?

Question

Accepted Answer

Go **không có kế thừa** — thay vào đó nó dùng **composition** thông qua struct embedding. Bằng cách nhúng (embed) một struct (hoặc interface) bên trong một struct khác, kiểu bên ngoài có được các trường và method của kiểu bên trong một cách trực tiếp. Đây là câu trả lời của Go cho việc tái sử dụng code, ưa composition "has-a" hơn kế thừa "is-a".

## Nhúng một struct

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // ĐƯỢC NHÚNG — không tên trường, chỉ kiểu → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog có các trường và method của Animal được THĂNG CẤP (promoted) — truy cập trực tiếp
fmt.Println(d.Name)     // "Rex" — được thăng cấp từ Animal được nhúng
fmt.Println(d.Eat())    // "Rex is eating" — method của Animal, gọi trên Dog
```

Nhúng (viết chỉ tên kiểu, không tên trường) **thăng cấp (promote)** các trường và method của kiểu được nhúng lên struct bên ngoài — nên `d.Name` và `d.Eat()` hoạt động như thể chúng thuộc về `Dog`. Điều này trông giống kế thừa nhưng là composition: `Dog` *có một* `Animal`.

## Ghi đè (override) các method được thăng cấp

```go
func (d Dog) Eat() string {        // Dog định nghĩa Eat() RIÊNG của nó
    return d.Name + " the dog eats noisily"
}
d.Eat()         // gọi Eat của Dog (cái bên ngoài che cái được nhúng)
d.Animal.Eat()  // gọi tường minh Eat của Animal được nhúng nếu cần
```

Kiểu bên ngoài có thể định nghĩa một method cùng tên để "ghi đè" (che) cái được thăng cấp; bạn vẫn có thể tiếp cận phiên bản được nhúng một cách tường minh.

## Nhúng interface (rất phổ biến)

```go
// nhúng interface để hợp thành các interface lớn hơn
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // hợp thành từ cả hai qua nhúng
    Reader
    Writer
}
// (đây chính xác là cách io.ReadWriter được định nghĩa trong thư viện chuẩn)
```

Nhúng interface hợp thành các interface nhỏ thành các interface lớn hơn — được dùng khắp thư viện chuẩn.

## Composition over inheritance — triết lý Go

```text
Không có cây phân cấp class, không có "extends". Thay vào đó:
  ✓ Nhúng để tái sử dụng trường/method (has-a)
  ✓ Nhúng interface để hợp thành các hợp đồng hành vi
  ✓ Tránh sự dễ vỡ, cây phân cấp sâu, và ràng buộc chặt của kế thừa
```

## Tại sao điều này quan trọng

Struct embedding là cơ chế đặc trưng của Go cho **tái sử dụng code và composition**, thay thế kế thừa có ở hầu hết các ngôn ngữ OOP.

Hiểu nó là thiết yếu vì đó là cách Go đạt được tái sử dụng (thăng cấp các trường/method được nhúng để kiểu bên ngoài "kế thừa" hành vi qua composition) trong khi cố tình tránh các vấn đề nổi tiếng của kế thừa (fragile base class, cây phân cấp cứng nhắc sâu, ràng buộc chặt).

Nó thể hiện nguyên tắc được ủng hộ rộng rãi **"composition over inheritance"**.

Embedding xuất hiện liên tục — nhúng struct để tái sử dụng, nhúng interface để xây các hợp đồng lớn hơn (như `io.ReadWriter`), và nhúng cho hành vi kiểu mixin.

Nhận ra rằng Go không có kế thừa và embedding là giải pháp composition thay thế của nó — cộng với các quy tắc thăng cấp và che method — là nền tảng để đọc và thiết kế Go idiomatic, và là một chủ đề phỏng vấn phổ biến vì nó khác với các ngôn ngữ dựa trên class.