Go与C+中的抽象基类设计+； 我仍然在学习C++的背景下的做事方法。我正在寻找将OOP继承与接口组合进行对比的反馈 我在GO程序中有一个设计的情况，如果我在C++中实现，我会用一个抽象基类来解决。p>

假设我需要一个基类，它有许多实现者。基类具有处理抽象数据项的共享方法。不同的Worker实现在不同的项类型上提供CRUD操作，但是Worker都使用基类的共享方法进行一般工作

在C++中，我可能这样做< /P>

class IItem
{
    // virtual methods
};

class IWorker
{
public:
    // one of many virtual functions that deal with IItem CRUD
    virtual IItem* createItem() = 0; 

    // concrete method that works on interfaces
    void doWork()
    {
        IItem* item = createItem();
        // do stuff with an IItem*
    }

};


class Toy : public IItem
{

};

// one of many kinds of workers
class ElfWorker : public IWorker
{
public:

    ElfWorker()
    {
        // constructor implicitly calls IWorker()
    }

    IItem* createItem() override
    {
        return new Toy;
    }
};

在Go中，没有抽象的虚拟方法，例如IWorker:：createItem（）。具体的类需要为基类提供一个接口或函数来做正确的事情

因此，我认为在这种情况下，必须使用指向ElfWorker的指针显式地设置ew.ItemCRUD接口的Go代码

elf知道如何创建Item（），在他的例子中，它恰好是玩具对象。其他工作人员将为其数据对象实现自己的ItemCRUD

type Item interface {                         
    // various methods                                                                                
}
type ItemCRUD interface {                                                                             
    create() Item                                                                                     
    // other CRUD                                                                                     
}                                                                                                     

type Worker struct {
    ItemCRUD  // embedded interface                                                                                        
}                                                                                                     
func (w *Worker) doWork() {
    item := w.create()                                                                                
    // do stuff with item                                                                          
}

type Toy struct {
}

type ElfWorker struct {                                                                               
    Worker // embedded                                                                                
    // ..
}       

func NewElfWorker() *ElfWorker {                                                                      
    ew := &ElfWorker{}                                                                                
    ew.ItemCRUD = ew // <-- #### set Worker ItemCRUD  explicitly ####                                                  
    return ew                                                                                         
}                                                                                                     

func (ew *ElfWorker) createItem() Item {
    return &Toy{}                                                                                     
}
// more ElfWorker Item CRUD
func bigFunction(w *Worker) {                                                                     
    // ...                                                                                            
    w.doWork()  
   // ..                                                                                       
}   

类型项接口{
//各种方法
}
类型ItemCRUD接口{
create（）项
//其他积垢
}                                                                                                     
类型工作结构{
ItemCRUD//嵌入式接口
}                                                                                                     
func（w*工人）doWork（）{
项：=w.create（）
//处理物品
}
类型玩具结构{
}
类型ElfWorker结构{
工人//嵌入式
// ..
}       
func NewElfWorker（）*ElfWorker{
ew:=&ElfWorker{}
ew.ItemCRUD=ew/我自己是新手，这个答案没有多年的围棋经验支持：-）

我不知道，你解决这个问题的方法是否正确。
go允许在没有显式声明的情况下实现接口。如果您有ELVE，并且需要它们执行
ItemCRUD
方法，只需实现它们即可

然后，方法集将匹配接口，您可以在需要时将elf用作
ItemCRUD

要为任何elf对象提供默认的
ItemCRUD
实现，您应该为
ItemCRUD
实现一个适配器，并用抽象elf组成适配器。抽象方法的默认实现可能是
log.Fatal（“未实现”）

具体的精灵隐藏适配器的方法，这回答了您的问题：在创建过程中不需要插入对象

然而，由于go没有泛型，因此使用
ItemCRUD
可能不是正确的方法。我不完全清楚上面的代码的计划是什么，并且不了解很难提出具体的解决方案，很清楚的是，你是带着既定的OOP思维来参加聚会的（我也这么做了）这对找到golang的最佳解决方案几乎没有帮助

在Golang中，我通常不会在一个实现中嵌入接口，接口在Golang中是隐式满足的，这使得期望和实现可以很好地分离，这通常应该得到尊重。
Receiver方法应该期望一个接口，在运行时传递的实现应该隐式地满足该接口的签名

所以，也许我的doWork方法需要能够创建Items，那么它将是doWork方法，它将接受ItemCRUD的任何实现，它可以调用ItemCRUD来创建一个item。但这是我在猜测您在这里真正想要做什么，我怀疑如果您只是将实现与接口分离，您可能会回答您自己的问题“C++”和其他语言之间的并列可以证明是反生产的。一阶导数到@罗恩的评论：应用其他编程语言中找到的模式去证明是适得其反的。我投票把这个问题关为离题，因为它应该被转移到CoeDeVIEWWIN投票，因为我要求反馈。一个设计选择？我想我清楚地说明了我想学习的是什么？我预先说明了语言将以不同的方式解决问题。