Inheritance in GO using struct (Embedding)

This post desicribes inheritance using struct only. Do visit our Inheritance in Go Complete Guide post for full reference

OOP: Inheritance in GOLANG complete guide

Go supports inheritance by embedding struct or using interface. There are different ways of doing it and each having some limitations. The different ways are:

1. By using embedded struct – The parent struct is embedded in child struct. The limitation is that subtyping is not possible with this approach. You cannot pass the child struct to a function that expects base. The current post describes this approach.
2. By using interfaces – Subtyping is possible but the limitation is that one has no way to refer to common properties. Refer this link for more details – Inheritance using Interface
3. By using interface + struct – This fixes the limitations of above two approach but one limitation is that overriding methods is not possible. But there is a workaround. Refer to this link for more details – Inheritance using interface + struct

Details:

In inheritance using a struct, a base struct is embedded in child struct and base properties and methods can directly be called on child struct. See below code:

package main

import "fmt"

type base struct {
	value string
}

func (b *base) say() {
	fmt.Println(b.value)
}

type child struct {
	base  //embedding
	style string
}

func check(b base) {
	b.say()
}

func main() {
	base := base{value: "somevalue"}
	child := &child{
		base:  base,
		style: "somestyle",
	}
	child.say()
	//check(child)
}

Output:

somevalue

Limitation:

Subtyping is not supported. You cannot pass the child struct to a function that expects base.

For example in the above code if you uncomment //check(child) it will give compilation error: “cannot use child (type *child) as type base in argument to check”. To fix this we can do inheritance using Interface