當(dāng)我們談?wù)摮淌皆O(shè)計(jì)時，我們通常指的是編寫一堆修改某些資料並與某些資料互動的函數(shù)。物件導(dǎo)向程式設(shè)計(jì)（OOP）是一種程式設(shè)計(jì)模型，它專注於包含資料並附加一些相關(guān)功能的「物件」。物件導(dǎo)向程式設(shè)計(jì)有四大支柱：繼承、封裝、多態(tài)性與抽象。在本部落格中，我們將透過範(fàn)例了解如何在 Golang 中實(shí)現(xiàn)它們中的每一個。推薦一些有關(guān) OOP 的基本概念，但如果沒有，我將簡要介紹所有四個支柱的含義。

類別、物件和方法

物件導(dǎo)向程式設(shè)計(jì)的核心思想可以概括為以下幾點(diǎn)：

• 您定義“類別”，它們是資料和可以呼叫該資料的函數(shù)的集合。
• 這些特定的函數(shù)稱為該特定類別的「方法」。
• 類別的實(shí)際實(shí)例稱為「物件」。

讓我們來看一些 Golang 中的程式碼來理解這三個概念：

package main

import "fmt"

type Batman struct {
    actor string
    year int
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b.actor, b.year)
}

func main() {
    b1 := Batman{actor: "Michael Keaton", year: 1989}
    b2 := Batman{actor: "Christian Bale", year: 2005}

    b1.SayImBatman()
    b2.SayImBatman()
}

在Golang中，類別只不過是我們定義的型別。這些類型不一定必須是結(jié)構(gòu)體，但通常都是結(jié)構(gòu)體，因?yàn)樵?OOP 中我們使用資料集合，這些資料可以是任何類型（字串、整數(shù)等）。

類別是物件的藍(lán)圖。每當(dāng)實(shí)例化一個類別時，就會形成一個物件。在此範(fàn)例中，b1 和 b2 是 Batman 類別的物件。

SayImBatman 函數(shù)可以在該類別的任何物件上呼叫。由於它與 Batman 類別相關(guān)，因此不稱之為常規(guī)函數(shù)，而是稱為類別的方法。

我認(rèn)為這應(yīng)該足以讓您清楚 OOP 的基礎(chǔ)知識，以便您繼續(xù)進(jìn)行下一部分，我們將在其中介紹 OOP 的四大支柱。

遺產(chǎn)

繼承引入了 OOP 中 parent 和 child 類別的概念。子類別是從父類別派生的類，並繼承其所有方法和屬性（資料）。讓我們來看看一些程式碼來幫助我們理解這一點(diǎn)：

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

在此範(fàn)例中，蝙蝠俠和鋼鐵人是 Hero 父類的子類別。他們可以存取其父類別的屬性（即 team）及其方法（即 SayTeam）。正如您在聲明 b1 和 i1 實(shí)例時所看到的那樣，我們指定了父類別屬性以及它們各自類別的特定屬性。它們都能夠呼叫父類別中定義的 SayTeam 方法。但它們也有各自獨(dú)特的屬性和方法。

Golang 使用組合（在結(jié)構(gòu)體中使用結(jié)構(gòu)體）來實(shí)現(xiàn)繼承。它不像其他 OOP 語言（例如 C 或 Java）那樣具有內(nèi)建的基於類別的繼承。

封裝

封裝是隱藏物件內(nèi)部屬性且不允許直接修改它們的原理。相反，它依賴於提供獲取和更新這些屬性的方法。讓我們看一個例子來更好地理解這一點(diǎn)：

package main

import "fmt"

type Batman struct {
    actor string
    year int
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b.actor, b.year)
}

func main() {
    b1 := Batman{actor: "Michael Keaton", year: 1989}
    b2 := Batman{actor: "Christian Bale", year: 2005}

    b1.SayImBatman()
    b2.SayImBatman()
}

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

在Golang中，從套件中導(dǎo)出的屬性和方法以大寫字母開頭。當(dāng)我們在utils包中定義小寫的actor和year時，我們確保它們不能被直接修改。相反，就像您在 main.go 檔案中看到的那樣，您需要使用匯出的方法（以大寫字母開頭） - GetActor、SetActor 等來獲取和修改它們。

這就是封裝的全部內(nèi)容 - 確保防止資料意外更改，並提供與資料安全互動的方法。

您會注意到不同的一件事是，在 Batman 類別的所有方法中，我們使用指標(biāo)接收器 *Batman 而不是像前面範(fàn)例中那樣使用值接收器 Batman。這是因?yàn)槲覀兿Ｍ軌蛟?Set 方法中修改原始結(jié)構(gòu)。在 Golang 中，最佳實(shí)踐是，如果某些方法需要指標(biāo)接收器，則讓所有方法都使用指標(biāo)接收器以保持一致性。這就是為什麼 Get 方法也使用指標(biāo)接收器，即使它們沒有修改原始結(jié)構(gòu)。

此外，還要注意的一件事是，僅僅因?yàn)槲覀兪褂玫氖侵笜?biāo)接收器，我們就不必這樣做：(&b1).GetActor。在 Golang 中，帶有指針參數(shù)的函數(shù)必須採用指針，但帶有指針接收器的方法可以採用值或指針作為接收器。

TL;DR：Golang 自動將b1.GetActor 轉(zhuǎn)換為(&b1).GetActor，因?yàn)镚etActor 方法有一個指標(biāo)接收器，但如果GetActor 是一個普通函數(shù)，它不會將GetActor(b1) 轉(zhuǎn)換為GetActor( &b1)一個指標(biāo)參數(shù)。

多態(tài)性與抽象

OOP 的接下來兩個支柱可以合併在一起，因?yàn)樗鼈兊某淌酱a範(fàn)例看起來非常相似。多態(tài)性是指兩個不同類別的兩個不同物件可以被視為同一公共超類別的物件的程式設(shè)計(jì)實(shí)踐。這意味著您可以在兩個不同的物件上呼叫相同的函數(shù)，就好像它們是同一類別的物件一樣。這應(yīng)該開始讓您感受到所涉及的介面的味道:)

讓我們看一些程式碼來更好地理解這一點(diǎn)：

package main

import "fmt"

type Batman struct {
    actor string
    year int
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b.actor, b.year)
}

func main() {
    b1 := Batman{actor: "Michael Keaton", year: 1989}
    b2 := Batman{actor: "Christian Bale", year: 2005}

    b1.SayImBatman()
    b2.SayImBatman()
}

在此範(fàn)例中，StartFight 函數(shù)可以傳遞 b1 和 i1 對象，即使它們彼此沒有任何關(guān)係。試著理解這與繼承有何不同，在繼承中，子類別可以存取父類別的方法。在此範(fàn)例中，沒有子類別和父類別（也沒有共用方法）。相反，兩個不同的物件被函數(shù)視為相同：這稱為多態(tài)性。

現(xiàn)在，這也可以被視為抽象的例子。顧名思義，抽像是一種隱藏實(shí)作細(xì)節(jié)，而只是提供為您處理事務(wù)的函數(shù)的程式設(shè)計(jì)實(shí)踐。在這個例子中，你不需要關(guān)心單一英雄的方法是如何被配置的。當(dāng)您想使用任何英雄的戰(zhàn)鬥功能時，您可以隨時繼續(xù)使用開始戰(zhàn)鬥功能。這樣，實(shí)作細(xì)節(jié)對使用者來說是隱藏的，只暴露基本的細(xì)節(jié)。

現(xiàn)在回到多態(tài)，有兩個更常見的例子，那就是方法重寫和重載。

方法重寫

方法重寫是指子類別定義自己的父類別中定義的方法的實(shí)作?，F(xiàn)在使用此實(shí)作來代替原始父類別的實(shí)作。讓我們看看之前用於繼承的程式碼，看看它在方法重寫後的樣子：

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

程式的輸出是：

//oops-in-go/utils/utils.go

package utils

type Batman struct {
    actor string
    year int
}

func (b *Batman) GetActor() string {
    return b.actor
}

func (b *Batman) GetYear() int {
    return b.year
}

func (b *Batman) SetActor(actor string) {
    b.actor = actor
}

func (b *Batman) SetYear(year int) {
    b.year = year
}

Batman 類別的物件現(xiàn)在使用自己的 SayTeam 方法，而不是父 Hero 類別的方法。由於 Ironman 類別沒有自己的 SayTeam 方法，因此它的物件仍然使用其父類別的方法。這就是方法重寫的意思，子類別「重寫」父類別中定義的方法。

方法重載

這是指同一個函數(shù)能夠接受多個不同的參數(shù)。這些參數(shù)的數(shù)量或類型可能不同。 Golang 提供了兩種方法來實(shí)現(xiàn)這一點(diǎn)：透過可變參數(shù)函數(shù)，另一種透過介面。

讓我們來看看兩者的程式碼，這將幫助您更好地理解：

使用可變參數(shù)函數(shù)

// oops-in-go/main.go

package main

import (
    "fmt"
    "oops-in-go/utils"
)

func main() {
    b1 := utils.Batman{}
    b1.SetActor("Michael Keaton")
    b1.SetYear(1989)
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b1.GetActor(), b1.GetYear())

    b1.SetActor("Christian Bale")
    b1.SetYear(2005)
    fmt.Printf("I'm %s and I'm Batman from year %d\n", b1.GetActor(), b1.GetYear())
}

在這裡，您可以使用任意數(shù)量個參數(shù)「重載」listMembers函數(shù)。

使用介面

package main

import "fmt"

type Hero interface {
    Fight()
}

type Batman struct {
    weapon string
}

type Ironman struct {
    weapon string
}

func (b Batman) Fight() {
    fmt.Printf("Batman hits with a %s\n", b.weapon)
}

func (i Ironman) Fight() {
    fmt.Printf("Ironman hits with a %s\n", i.weapon)
}

func StartFight(h Hero) {
    fmt.Println("Fight has started.")
    h.Fight()
}

func main() {
    b1 := Batman{"Batarang"}
    i1 := Ironman{"Repulsor rays"}

    StartFight(b1)
    StartFight(i1)
}

程式的輸出是：

package main

import "fmt"

type Hero struct {
    team string
}

type Batman struct {
    Hero
    name string
}

type Ironman struct {
    Hero
    power int
}

func (h Hero) SayTeam() {
    fmt.Println("My Team is", h.team)
}

func (b Batman) SayImBatman() {
    fmt.Printf("I'm %s and I'm Batman\n", b.name)
}

func (i Ironman) SayPowerLevel() {
    fmt.Printf("I'm Ironman and my powerlevel is %d\n", i.power)
}

func (b Batman) SayTeam() {
    fmt.Printf("I'm Batman and my team is %s\n", b.team)
}

func main() {
    b1 := Batman{Hero{team: "Justice League"}, "Christian Bale"}
    i1 := Ironman{Hero{team: "Avengers"}, 23}

    b1.SayImBatman()
    b1.SayTeam()

    i1.SayPowerLevel()
    i1.SayTeam()
}

這裡我們「重載」了 saySomething 方法來接受不同類型的參數(shù)。我們採用一個空介面作為參數(shù)，它可以是任何類型，然後使用 switch case 檢查其類型並相應(yīng)地列印輸出。

結(jié)論

我很清楚這是一篇很長的文章，如果您堅(jiān)持讀到最後，我想讓您知道我真的很高興:) 我真誠地希望您學(xué)到很多有關(guān)面向?qū)ο缶幊痰男轮R以及如何在Golang 中實(shí)現(xiàn)它。我在我的網(wǎng)站上撰寫有關(guān)不同技術(shù)概念的博客，如果您有興趣學(xué)習(xí)新事物，我建議您訂閱我的時事通訊。

以上是Golang 中的物件導(dǎo)向程式設(shè)計(jì) (OOP) 簡介的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！