首先聲明下go 沒有繼承，沒有繼承，沒有繼承，重要事情說三遍。但是他又能實現(xiàn)繼承，通過一個神奇的東西 - 結(jié)構(gòu)體。

那么抽象類的使用場景是什么呢？

• 定義了一組接口，但又不想強迫每個實現(xiàn)類都必須實現(xiàn)所有的接口。可以用abstract class定義一組方法體，甚至可以是空方法體，然后由子類選擇自己所感興趣的方法來覆蓋。

• 某些場合下，只靠純粹的接口不能滿足類與類之間的協(xié)調(diào)，還必需類中表示狀態(tài)的變量來區(qū)別不同的關(guān)系。abstract的中介作用可以很好地滿足這一點。

• 規(guī)范了一組相互協(xié)調(diào)的方法，其中一些方法是共同的，與狀態(tài)無關(guān)的，可以共享的，無需子類分別實現(xiàn)；而另一些方法卻需要各個子類根據(jù)自己特定的狀態(tài)來實現(xiàn)特定的功能

說人話就是：規(guī)范了執(zhí)行方法，想覆蓋就重寫，不想覆蓋就用父類的就好了

在這些情況下，我們需要使用抽象類繼承，來幫助我們寫出更優(yōu)雅的代碼?？墒窃?golang 中又沒有抽象類的概念，哪有如何呢？
那不得不介紹一種通過 struct 和 interface 來在 golang 中實現(xiàn)抽象類的方法。

因為go 里面沒有extends abstract 這些關(guān)鍵字，那么先從大家所熟悉的主流語言java 來引入一段代碼

java實現(xiàn)抽象類

1.創(chuàng)建抽象父類

package abstractModel;

public abstract class CatAbstract {

    public abstract void steeringWheel();
    public void run(){
        System.out.println("我是父類方法-run，大家一起跑起來~");
    }
}

我創(chuàng)建了一個公共的方法run或者換一種名字叫做默認方法
另外創(chuàng)建一個抽象方法steeringWheel，子類都需要實現(xiàn)的

2.創(chuàng)建2個子類
第一個aodi的

package abstractModel;

public class Audi extends CatAbstract{
    @Override
    public void steeringWheel() {
        System.out.println("我是奧迪的方向盤");
    }
}

第二個benchi的

package abstractModel;

public class Benz extends CatAbstract{
    @Override
    public void steeringWheel() {
        System.out.println("我是奔馳的方向盤");
    }

    @Override
    public void run() {
        System.out.println("我奔馳nb  有自己的方式跑起來");
    }
}

運行如下

package abstractModel;

public class AbstractMain {

    public static void main(String[] args) {
        Audi audi = new Audi();
        audi.steeringWheel();
        audi.run();

        System.out.println("-----華麗分界線----");

        Benz benz = new Benz();
        benz.steeringWheel();
        benz.run();
    }
}

image.png

只要重寫了父類那么就用子類的，沒實現(xiàn)就用父類的，抽象方法一定要在子類實現(xiàn)。
好了，現(xiàn)在咱們用go 來實現(xiàn)這段java代碼

Go 實現(xiàn)抽象類

先來實現(xiàn)第一個父類

package abstractClass

import "fmt"

type CatAbstract struct {
    ICatAbstract
}

type ICatAbstract interface {
    SteeringWheel()
    Run1()
}

func (c *CatAbstract) Run1() {
    fmt.Println("我是父類方法-run，大家一起跑起來~")
}

創(chuàng)建一個interface 里面同樣有2個方法。這2個方法放到這里，起子類可以都來實現(xiàn)它，假如有一個默認的方法run1，那咱就默認把它給實現(xiàn)了，那么他就不是一個抽象方法了，其實go里面壓根就沒這個東西，咱們是為了實現(xiàn)它，而臨時定義的名字叫做抽象方法，記住go里萬物皆結(jié)構(gòu)體，比php萬物皆數(shù)據(jù)更強大（對go這種語言寫設(shè)計模式代碼，真的蛋疼）

創(chuàng)建2個子類

package abstractClass

import "fmt"

type Audi struct {
    CatAbstract
}

func (a *Audi) SteeringWheel() {
    fmt.Println("我是奧迪的方向盤")
}

定義的第一個類audi咱們就實現(xiàn)一個”抽象方法“ SteeringWheel
在創(chuàng)建另一個benz

package abstractClass

import "fmt"

type Benz struct {
    CatAbstract
}

func (b *Benz) SteeringWheel() {
    fmt.Println("我是奔馳的方向盤")
}

func (b *Benz) Run1() {
    fmt.Println("我奔馳nb  有自己的方式跑起來")
}

它就很聰明的實現(xiàn)了2個
看效果

package abstractClass

import (
    "fmt"
    "testing"
)

func TestAbstractClass(t *testing.T) {

    audi := &Audi{}
    audi.SteeringWheel()
    audi.Run1()

    fmt.Println("-----華麗分界線----")

    benz := &Benz{}
    benz.SteeringWheel()
    benz.Run1()
}

image.png

到這里就結(jié)束了，go沒有繼承，萬物皆結(jié)構(gòu)體，請不要用其他語言的編程思想來寫go，不然就是對自己的折磨。

請記住go沒有繼承，萬物皆結(jié)構(gòu)體
go 起來吧！