Go hỗ trợ lập trình hướng đối tượng như thế nào?

• Inheritance (tính kế thừa): Lớp cha có thể chia sẻ dữ liệu và phương thức cho các lớp con, các lớp con khỏi phải định nghĩa lại những logic chung, giúp chương trình ngắn gọn. Có 2 kiểu kế thừa trong OOP: kế thừa từ 1 đối tượng (single inheritance) với các ngôn ngữ tiêu biểu như PHP, C#, Java, Ruby, và đa kế thừa (multiple inheritance) như Perl, Python, C++.

• Polymorphism (tính đa hình): ở trong nhiều ngôn ngữ, tính đa hình và kế thừa đan xen vào nhau. Tính đa hình tạo ra mối quan hệ là-một (is-a relationship), trong khi tính kế thừa chỉ là sử dụng những phương thức, thuộc tính có sẵn. Tính đa hình định nghĩa 1 mối quan hệ có ngữ nghĩa giữa 2 (hoặc nhiều hơn) đối tượng. Còn tính kế thừa chỉ định nghĩa 1 mối quan hệ về mặt cú pháp.

• Object Composition (sự kết hợp đối tượng): là khi một đối tượng bao gồm các đối tượng khác, thay vì kế thừa từ các đối tượng này. Tức là thay vì mối quan hệ là-một (is-a) của tính đa hình, thì sử dụng mối quan hệ có-một (has-a) (1 đối tượng có 1 đối tượng khác bên trong).

Tính kế thừa trong Go

Go được thiết kế mà hoàn toàn không có tính kế thừa. Tuy nhiên, điều này không có nghĩa là giữa các đối tượng trong Go không có mối quan hệ nào, thay vào đó các tác gỉa của Go sử dụng 1 cơ chế khác để thể hiện các mối quan hệ này. Đây có thể coi là 1 tính chất tốt của Go, giúp giải quyết các tranh cãi từ lâu xung quanh tính kế thừa.

Tính đa hình và kết hợp trong Go

Thay vì tính thừa kế, Go dựa theo qui tắc Composition over inheritance, tức là 1 đối tượng A sẽ có sẵn các thuộc tính và phương thức của 1 đối tượng B bằng việc bao gồm đối tượng B đó luôn trong thành phần của mình. Go thể hiện tính đa hình và thành phần thông qua `struct` và `interface`.

Tình kết hợp đối tượng trong Go

Cơ chế được Go sử dụng để thể hiện tính kết hợp các đối tượng là nhúng dữ liệu (embedded types). Go cho phép chúng ta nhúng một `struct` bên trong 1 `struct` khác, tạo ra mối quan hệ có-một (has-a) giữa 2 struct.

Ở ví dụ dưới, chúng ta thấy rằng Address vẫn là 1 đối tượng, và được Person bao gồm trong nó. Có thể truy cập vào các trường trong Address bằng cách viết p.Address.tên_trường.

type Person struct {
   Name string
   Address Address
}
type Address struct {
   Number string
   Street string
   City   string
   State  string
   Zip    string
}
func (p *Person) Talk() {
    fmt.Println("Hi, my name is", p.Name)
}
func (p *Person) Location() {
    fmt.Println("I’m at", p.Address.Number, p.Address.Street, p.Address.City, p.Address.State, p.Address.Zip)
}
func main() {
    p := Person{
        Name: "Steve",
        Address: Address{
            Number: "13",
            Street: "Main",
            City:   "Gotham",
            State:  "NY",
            Zip:    "01313",
        },
    }
    p.Talk()  //  Hi, my name is Steve
    p.Location()  //  I’m at 13 Main Gotham NY 01313
}

Để mở rộng ví dụ trên, chúng ta sẽ tạo thêm 1 struct mới là `Citizen`, bao gồm `Person` trong nó. 1 Person có thể Talk, 1 Citizen là 1 Person, do vậy Citizen cũng có thể Talk.

type Citizen struct {   
  Country string   
  Person
}

func (c *Citizen) Nationality() {    
  fmt.Println(c.Name, "is a citizen of", c.Country)
}

func main() {    
  c := Citizen{}    
  c.Name = "Steve"    
  c.Country = "America"    
  c.Talk()    //  Hi, my name is Steve
  c.Nationality()  //Steve is a citizen of America
}

func (c *Citizen) Talk() {
    fmt.Println("Hello, my name is", c.Name, "and I'm from", c.Country)
}

func main() {
    c := Citizen{}
    c.Name = "Steve"
    c.Country = "America"
    c.Talk()         //  Hello, my name is Steve and I'm from America
    c.Nationality()  //  Steve is a citizen of America
}

func main() {
    c := Citizen{}
    c.Name = "Steve"
    c.Country = "America"
    c.Talk()         // >  Hello, my name is Steve and I'm from America
    c.Person.Talk()  // >  Hi, my name is Steve
    c.Nationality()  // >  Steve is a citizen of America
}

package main

type A struct{
}

type B struct {
    A  //B is-a A
}

func save(A) {
    //do something
}

func main() {
    b := B
    save(&b);  //OOOPS! b IS NOT A
}

//  prog.go:17: cannot use b (type *B) as type A in function argument
//   [process exited with non-zero status]

func SpeakTo(p *Person) {    
  p.Talk()
}

func main() {    
  p := Person{Name: "Dave"}    
  c := Citizen{Person: Person{Name: "Steve"}, Country: "America"}
  
  SpeakTo(&p)    
  SpeakTo(&c)    
  //  prog.go:48: cannot use c (type *Citizen) as type *Person in function argument
  //  [process exited with non-zero status]
}

type Human interface {    
  Talk()
}

func SpeakTo(h Human) {    
  h.Talk()
}

func main() {    
  p := Person{Name: "Dave"}    
  c := Citizen{Person: Person{Name: "Steve"}, Country: "America"}

  SpeakTo(&p)   //   Hi, my name is Dave 
  SpeakTo(&c)   //   Hi, my name is Steve
  
}