abstract class A{
 static method1(){
  ...
  method2();
  ...
 }
 abstract method2();
}
class B extends A{
 method2(){
  ...
 }
    
}
class C extends A{
 method2(){
  ...
 }
}

type Reader interface {
	Read(p []byte) (n int, err error)
}
type Writer interface {
	Write(p []byte) (n int, err error)
}
type ReadWriter interface {
	Reader
	Writer
}

package mypackage
func() Method1() { ... } // Below I will call it Function instead

package main
import "fmt"
type Methoder interface {
	Method()
}
func Function(m Methoder) {
	m.Method()
}
type StructB struct{}
func (s *StructB) Method() { fmt.Println("StructB") }
type StructC struct{} // You can do some "inheritance" by embedding a base struct
func (s *StructC) Method() { fmt.Println("StructC") }
func main() {    
	b := &StructB{}
	Function(b)    
}

StructB

component
  base
    types.go
    abstract.go
  impl1
    impl.go
  impl2
    impl.go
  types.go
  factory.go

package component
type IComponent interface{
    B() int
    A() int
    Sum() int
    Average() int
}

package base
type IAbstractComponentMembers {
    A() int
    B() int
}

package base
type AbstractComponent struct {
    IAbstractComponentsMember
}
func (a *AbstractComponent) Sum() int {
    return a.A() + a.B()
}
func (a *AbstractComponent) Average() int {
    return a.Sum() / 2
}

package impl1
type ComponentImpl1 struct {
    base.AbstractComponent
}
func (c *ComponentImpl1) A() int {
    return 2
}
func (c *ComponentImpl1) A() int {
    return 4
}
// Here is how we would build this component
func New() *ComponentImpl1 {
    impl1 := &ComponentImpl1{}
    abs:=&base.AbstractComponent{
        IAbstractComponentsMember: impl1,
    }
    impl1.AbstractComponent = abs
    return impl1
}

package component
// Default component implementation to use
const defaultName = "impl1"
var instance *Factory
type Factory struct {
    // Map of constructors for the components
    ctors map[string]func() IComponent
}
func (f *factory) New() IComponent {
    ret, _ := f.Create(defaultName)
    return ret
}
func (f *factory) Create(name string) (IComponent, error) {
	ctor, ok := f.ctors[name]
	if !ok {
		return nil, errors.New("component not found")
	}
	return ctor(), nil
}
func (f *factory) Register(name string, constructor func() IComponent) {
	f.ctors[name] = constructor
}
func Factory() *Factory {
    if instance == nil {
        instance = &factory{ctors: map[string]func() IComponent{}}
    }
    return instance
}
// Here we register the implementations in the factory
func init() {
    Factory().Register("impl1", func() IComponent { return impl1.New() })
    Factory().Register("impl2", func() IComponent { return impl2.New() })
}

package main
import (
        "fmt"
)
type Api interface {
        Sugar()
        Impl()
}
// Common sugar API implementation
type CommonSugar struct {
        BasicApi interface {
                Impl()
        }
}
func (s CommonSugar) Sugar() {
        fmt.Println("Calling Impl in Sugar")
        s.BasicApi.Impl()
        fmt.Println("Called Impl in Sugar\n")
}
// A implementation
type ImplA struct {
        CommonSugar
}
func (a *ImplA) Impl() {
        fmt.Println("A Impl")
}
func NewApiA() Api {
        impl := &ImplA{}
        impl.CommonSugar.BasicApi = impl
        return impl
}
// B implementation
type ImplB struct {
        CommonSugar
}
func (a *ImplB) Impl() {
        fmt.Println("B Impl")
}
func NewApiB() Api {
        impl := &ImplB{}
        impl.CommonSugar.BasicApi = impl
        return impl
}
func main() {
        api := NewApiA()
        api.Sugar()
        api = NewApiB()
        api.Sugar()
}

Calling Impl in Sugar
A Impl
Called Impl in Sugar
Calling Impl in Sugar
B Impl
Called Impl in Sugar

public abstract class A {
void method1(){
method2();}
abstract void  method2();
}

package main
import (
"fmt"
)
type AI interface {
method2()
}
type A struct {
AI
}
func (a * A) method1() {
a.method2()
}
type B struct {
*A
}
func (b *B) method2() {
fmt.Print("Hello from B method1\n")
}
func NewB() *B{
b := &B{}
a := &A{b}
b.A = a
return b	
}
type C struct {
*A
}
func (c *C) method2() {
fmt.Print("Hello from C method1\n")
}
func NewC() *C{
c := &C{}
a := &A{c}
c.A = a
return c	
}
func main() {
b := NewB()
b.method1()
c:= NewC()
c.method1()
}