很多人都说用go代替php或者java的最大短板就是写业务太反人类。经过最近的一些使用，发现确实与常见的java或者c++有些区别，在这里说明一下。

go继承多态的现状

go没有类的概念

也没有所谓的继承多态。所以按照常规用法开发相应的业务逻辑，确实不适用。

go只有struct和interface

struct类似于类，interface就是接口。没有c++这种，类里面有纯虚函数、虚函数的概念。

方法不需要写在struct中，定义方法时，指定是哪个struct的，就可以自动绑定。

在go中变量/函数名称大写，表示外部可见，小写就是不可见。可以认为用大小写表示了public和private的概念，没有protect的用法。

非侵入式

只要struct实现了interface所有方法，就自动帮你绑定，认为struct继承了interface，并不需要在struct中明确写出。这种叫做非侵入式继承，各有利弊。

type FI interface {
	T()
}

type DS struct {
	a int
}

// 直接实现接口方法，不用在结构体明确指出
func (s *DS) T() {
	fmt.Println(s.a)
}

案例

有一个公共模块A，A中有一个公共函数T，T中调用函数F，B继承A，并且重新实现了F，但是没有实现T。要求用B调用T的时候，可以调用到B实现的F。

C++实现

按照常见的有类概念的函数，实现如下

//.h
class A
{
public:
    int b{};
    void T();
    //纯虚函数和虚函数效果一样
    virtual void F() = 0;
};

class B : public A
{
public:
    void F() override;
};

//.cpp
void B::F()
{
    std::cout << b << std::endl;
}

void A::T()
{
    F();
}

//main
void test(A* ma)
{
    ma->T();
}

int main()
{
    B mb;
    mb.b = 11;
    test(&mb);
    return 0;
}

我们都按照public来设定，B继承了A，那么B中包含了A和B的所有成员函数和变量。实例化B，然后把B传给一个A（父类）的指针，实际上这个指针指向的还是B的数据，用A这个指针调用函数T，仍然会调用到B的实现。这是一个非常好用的地方，增加了开发的便利。

把统一调用函数写在父类；在子类对功能函数重新实现；调用逻辑都使用父类指针。

比如上面如果有B1 B2等等都继承了A，在F做不同实现，void test(A* ma)方法不用做任何修改。

go实现

interface 参数

//类似于父类
type DS struct {
	b int
}

//DS中公共调用的函数
func (s *DS) T() {
	s.F()
}

func (s *DS) F() {
	fmt.Println("DS")
}

type DS1 struct {
	DS
}

func (s *DS1) F() {
	fmt.Println("DS1")
}

func callfunc(s *DS) {
	s.T()
}

func main() {
	ds1 := DS1{}
	callfunc(&ds1)
}

上面会报错，*DS1不能转换为*DS，那么我们用go的interface进行转换，修改为如下

type DS struct {
	b int
}

func (s *DS) T() {
	s.F()
}

func (s *DS) F() {
	fmt.Println("DS")
}

type DS1 struct {
	DS
}

func (s *DS1) F() {
	fmt.Println("DS1")
}

func callfun(s interface{}) {
	switch s.(type) {
	case *DS1:
		ss := s.(*DS1)
		ss.T()
	}
}

func main() {
	ds1 := DS1{}
	callfun(&ds1)
}

上面不会报错，可以调用，但是打印出来的是DS。因为DS1没有实现T，所以调用的是DS的函数，在DS中调用F又会默认调用DS的实现。

再做如下修改

func callfun(s interface{}) {
	switch s.(type) {
	case *DS1:
		ss := s.(*DS1)
		ss.F()
	}
}

这样是可以了，只是还与S1有关系吗？

interface 接口

先看下面的实现

//类似父类
type DS struct {
	A int
}

//类似父类接口
type FI interface {
	F()
}

//子类实现
type DS1 struct {
	FI
	DS
}
func (s *DS1) F() {
	fmt.Println("111", s.A)
}

//子类实现
type DS2 struct {
	FI
	DS
}
func (s *DS2) F() {
	fmt.Println("222", s.A)
}

//统一调用
func T(f1 FI) {
	f1.F()
}
func test() {
	ds1 := &DS1{}
	ds2 := &DS2{}
	T(s1)
	T(s2)
}

这样貌似可以实现，但是T不能作为DS1/DS2父类的一个函数。什么意思呢？就是T只能这样写，不能像C++一样，成为父类的一个函数，然后把子类的实例转为父类传递过去，通过父类的类型调用到子类的实现。

如果把T写到interface FI中，那么DS1和DS2都必须实现这个方法，就相当于相通的代码逻辑实现了两遍。
如果把T写到struct DS中，那么DS就必须改为继承interface FI，不然DS无法调用F，如果DS继承interface FI，那么必须实现F，这样就和上面通过interface 参数实现一样了，因为T只有DS实现了，那么DS调用的时候会默认调用自己的F，就无法满足多态。

把子类作为interface放入到父类中

// 父类接口，定义重写的函数
type FI interface {
	F()
}

// 父类，把接口作为一个成员变量，类似于把子类指针作为成员变量
type DS struct {
	S FI
}
//父类实现统一调用函数
func (d *DS) T() {
    d.S.F()
}

//子类
type DS1 struct {
}
type DS2 struct {
}
// 子类实现重写方法
func (s *DS1) F() {
	fmt.Println("111")
}
func (s *DS2) F() {
	fmt.Println("222")
}

func test() {
	ds := DS{}
	ds1 := &DS1{}
	ds.S = ds1
    ds.T()
}

这种方法的坏处就是，要创建多次，创建好ds，还要创建ds1进行赋值，如果忘了，就相当于调用了空指针。并且在DS1结构体实现的F中还不能调用统一的变量。比如都有一个int b，放在哪里都不合适。放在FI中不行，因为接口不允许；放在DS中不行，因为DS1调用不到（DS1没有继承DS）；放在DS1中也不行，因为不同通用，每个实现（DS2）也要增加这个成员。