Equivalence of abstract classes/methods (Java) in Google Go

I am new to Go and I'm wondering how I can implement a structure similar to abstract classes & methods in Java. In Java, I'd do the following:

abstract class A{

 static method1(){
  ...
  method2();
  ...
 }

 abstract method2();

}

class B extends A{

 method2(){
  ...
 }
    
}

class C extends A{

 method2(){
  ...
 }

}

I know about interfaces and structs. I could build an interface and then a struct to implement method1. But what about method2?
I know that I can embed one interface in another and also a struct as a field of another struct. But I don't see a way to implement my structure with those methods.

The only solution I see is to implement method1 both in class B and class C. Isn't there another way?

Note: of course in my case it's not just one method. Also I've got a hierarchy of abstract classes and don't really want to move everything down to the 'subclasses'.

The examples I've found on the internet are mostly with only one method per interface. It would be great if one of you guys could give me a hint here! Thanks.

You can have composite interfaces, for example from the io package :

http://golang.org/src/pkg/io/io.go?s=2987:3047#L57

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
}

As a side note, don't try to implement java code using go, try to learn the Go Way.

Since Go does not have static methods in the OOP sense, you often see those types of methods being implemented as package level functions:

package mypackage

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

Such package level functions would then take an interface as an argument. Your code would in that case look something like this:

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

Output:

StructB

This is the way I achieved implementing an abstract class the easy way avoiding to run into cyclic references and maintaining good factory patterns.

Let us assume we have the following package structure for our component

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

Define the definition of the component, in this example it will be defined here:

component/types.go

package component

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

Now let's assume we want to create an abstract class that implements Sum and Average only, but in this abstract implementation we would like to have access to use the values returned by the implemented A and B

To achieve this, we should define another interface for the abstract members of the abstract implementation

component/base/types.go

package base

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

And then we can proceed to implement the abstract "class"

component/base/abstract.go

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
}

And now we proceed to the implementations

component/impl1/impl.go // Asume something similar for impl2

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
}

The reason we use a separate interface for this instead of using the same IComponent interface, is because if we use the same interface in this case, if we import the base package in impl* to use the abstract "class" and also we import the impl* packages in the components package, so the factory can register them, we'll find a circular reference.

So we could have a factory implementation like this

component/factory.go

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

Go gets its object oriented concepts from Small Talk, not Simula like C++ and not from Java which gets its OO concepts from C++. Remember this and Go will suddenly become clear and obvious.

Thus, there is no concept of class in Go. Just objects, sending and receiving messages. Go's interfaces can be conceptually explained as collection of messages.

Go types do not “implement” interfaces, they just implement messages that are part of some interface.

Repeat: there is no class, no abstract base class and thus there is no “class based design” in Go (as in Small Talk).

No wonder trying to implement ABC in Go is a mess, as we see here clearly.

I use this trick to implement some sugar API with common implementations:

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

Here's the program output:

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

The example you are asking would not compile in Java unless you remove static keyword from method1, so the correct abstract class in Java would like like this.

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

To provide equivalent in go-lang you would have to use an interface in the following way: Go Playground

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

Since this still not may be easy how to translate/implement java abstract classes/multi-inheritance to go-lang here is the post with comprehensive details. Abstract Class in golang