Abstract base class design in GoLang vs C++ : I am still learning the Go way of doing things, coming from a C++ background. I am looking for feedback contrasting OOP inheritance to interface composition.

 I have a design situation in a Go program where, if I was implementing in C++, I would solve with an abstract base class. 


Suppose I need a base class, which has many implementors. The base class has shared methods that do work on abstract data items.  Different Worker implementations provide CRUD operations on different item types, but workers all use the shared methods of the base class for general work. 

In C++ I might do it this way
   

     
    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;
        }
    };

in golang you dont have abstract virtual methods such as IWorker::createItem().  Concrete classes need to supply the base with an interface or function that do the right thing.  

So I think it is the case that the golang code the ew.ItemCRUD interface has to be explicitly set with a pointer to an ElfWorker. 

 The elf knows how to createItem(), which in his case happens to be Toy object. Other workers would implement their own ItemCRUD for their data objects. 

                                                                                                           
    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()  
       // ..                                                                                       
    }   
    
    
     

So the part that I am wrestling a bit with is explicit setting.  Seems like the "Go way" of composition does require this **explicit** step if I want the base Worker class to provide shared methods on Items.

Thoughts? 