golang中有類嗎

這篇文章主要介紹“golang中有類嗎”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“golang中有類嗎”文章能幫助大家解決問題。

golang中沒有類。golang不是一門純面向對象編程語言，它沒有class（類）的概念，也就沒有繼承的說法，但Go也可以模擬面向對象的編程方式。在Go中，可以將struct比作其它語言中的class；通過struct定義結構體，表征一類對象，例“type person struct {...}”。

面向對象三大特征：封裝，繼承，多態。

Go不是一門純面向對象編程語言，它沒有class（類）的概念，也就沒有繼承的說法。但Go也可以模擬面向對象的編程方式，即可以將struct比作其它語言中的class。

對象

Go沒有class的概念，通過struct定義結構體，表征一類對象。

type person struct {
	Age  int
	Name string
}

對象是狀態與行為的有機體。例如下面的java代碼：

public class Person {

    int age;

    String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

不同于Java，Go的方法不需要跟類的數據綁定在一個class的定義里面，只需要定義在同一個包內。這一點可能初學Go的同學，會感覺很奇怪。

type person struct {
	Age  int
	Name string
}

func (p *person) GetAge() int {
	return p.Age
}

func (p *person) SetAge(age int)  {
	p.Age = age
}

func (p *person) GetName() string {
	return p.Name
}

func (p *person) SetName(name string) {
	p.Name = name
}

構造函數

Go沒有構造函數，對象的數據載體就是一個struct。Java支持構造函數，構造函數名字就跟類名字一樣，多個構造函數通過函數重載實現。

而Go構造函數則通過工廠函數進行模擬。實例如下：

type person struct {
	Age  int
	Name string
}

/**
	構造函數1--通過名字初始化
 */
func newPersonByName(name string) *person {
	return &person{
		Name: name,
	}
}

/**
	構造函數2--通過年齡初始化
 */
func newPersonByAge(age int) *person {
	return &person{
		Age: age,
	}
}

需要注意的是，person結構體的名稱首字母要小寫，避免外部直接越過模擬的構造函數

訪問權限

Java有四種訪問權限，如下所示：

Go則做了簡化，可見性的最小粒度是包。也就是說，Go保留兩種，friendly和public。Go的變量名如果首字母是小寫，則代表包內可見；如果首字母是大寫，則代表任何地方都可見。

封裝

封裝，把抽象出來的結構體跟操作結構體內部數據的函數綁定在一起。外部程序只能根據導出的函數API（public方法）修改結構體的內部狀態。

封裝有兩個好處：

隱藏實現：我們只希望使用者直接使用API操作結構體內部狀態，而無需了解內部邏輯。就好像一座冰山，我們只看到它露出水面的那一部分。

保護數據：我們可以對數據的修改和訪問施加安全措施，調用setter方法的時候，我們可以對參數進行校驗；調用getter方法，我們可以增加訪問日志等等。

一個簡單的bean定義如下所示：

type person struct {
	Age  int
	Name string
}

func NewPerson(age int, name string) *person{
	return &person{age, name}
}

func (p *person) SetAge(age int)  {
	p.Age = age
}

func (p *person) SetName(name string) {
	p.Name = name
}

func main() {
	p:= NewPerson(10, "Lily")
	p.SetName("Lucy")
	p.SetAge(18)
}

需要注意的是，Go的方法是一種特殊的函數，只是編譯器的一種語法糖，編譯器瞧瞧幫我們把對象的引用作為函數的第一個參數。例如，下面的代碼是等價的

func main() {
	p:= NewPerson(10, "Lily")

	p.SetName("Lily1")
	// 等價于下面的寫法
	// p是一個引用，函數引用
	setNameFunc := (*person).SetName
	setNameFunc(p, "Lily2")
	fmt.Println(p.Name)
}

繼承

繼承，子類繼承父類，則獲得父類的特征和行為。繼承的主要目的是為了重用代碼。Java實現代碼重用的兩大利器，就是繼承和組合。

Go沒有class的概念，談不上繼承。但Go可以通過匿名組合來模擬繼承。

如下所示，Cat通過匿名聚合了Animal結構體，就自動獲得了Animal的move()和Shout()方法：

type Animal struct {
	Name string
}

func (Animal) move()  {
	fmt.Println("我會走")
}

func (Animal) shout()  {
	fmt.Println("我會叫")
}

type Cat struct {
	Animal // 匿名聚合
}

func main() {
	cat := &Cat{Animal{"貓"}}

	cat.move()
	cat.shout()
}

多態

多態，申明為基類的變量，可以在運行期指向不同的子類，并調用不同子類的方法。多態的目的是為了統一實現。

我們通過接口來實現多態。在java里，我們通過interface來定義接口，通過implements來實現接口。

interface Animal {

    void move();

    void shout();
}

class Dog implements Animal {

    @Override
    public void move() {
        System.out.println("我會走");
    }

    @Override
    public void shout() {
        System.out.println("我會叫");
    }
}

而Go則是通過鴨子類型推斷，只要某個對象長得想鴨子，叫起來像鴨子，那么它就是鴨子。也就是說，Go的接口是比較隱匿的，只要某個對象實現來接口申明的所有方法，那么就認為它屬于該接口。

type Animal interface {

	move()
	shout()
}

type Cat struct {
	Animal // 匿名聚合
}

func (Cat)move()  {
	fmt.Println("貓會走")
}

func (Cat)shout()  {
	fmt.Println("貓會叫")
}

type Dog struct {
	Animal  // 匿名聚合
}


func (Dog)move()  {
	fmt.Println("狗會走")
}

func (Dog)shout()  {
	fmt.Println("狗會叫")
}

func main() {
	cat := Cat{}
	dog := Dog{}
    // 申明接口數組
 	animals := []Animal{cat, dog}
	for _,ele := range animals {
        // 統一訪問
		ele.move()
		ele.shout()
	}
}

關于“golang中有類嗎”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。