Polymorphism in Go

Other topics in this series - Table of Contents

Sometimes I’ve found it easier to explain polymorphism with an illustration. An illustration attempts to simplify and has its drawbacks, but it could help clarify the idea. Assume a martian came to earth and he knows about humans but he doesn’t know about the difference between a man and a woman. He now approaches random humans on the street and asks the same question, "Human, tell me what you like to do". Assume now that the first human the martian approached with this question is a Man. To go by a western stereotype, his response could be "I like fishing". Now assume it approached a Woman with the same question. Continuing with stereotypes, her response could be "I like shopping". As far as the martian sees it, it appears that he has asked only a Human, but he got a different answer each time. The answer depended on the actual type of the person he asked. Silly example might be, but this is similar to polymorphism - where different responses are obtained from the same type, in this case Human, depending on what specific type it is.

In Go, we use interfaces to achieve this polymorphism. For a starter tutorial on interfaces in Go, please read this tutorial: Interfaces in Go. If we created an interface and had other types implement that interface, then we can reach into each of those types via the defined methods of the interface without having to know what the specific type was. Let’s just implement that and see what we get.

Full code

package main

import "fmt"

type Human interface {
    myStereotype() string
}

type Man struct {
}

func (m Man) myStereotype() string {
    return "I'm going fishing."
}

type Woman struct {
}

func (m Woman) myStereotype() string {
    return "I'm going shopping."
}
func main() {
    m := new (Man)
    w := new (Woman)

    //an array of Humans - we don’t know whether Man or Woman
    hArr := [...]Human{m, w} //array of 2 Humans. One is the type Man, one is the type Woman.
    for n, _ := range (hArr) {

        fmt.Println("I'm a human, and my stereotype is: ", hArr[n].myStereotype())   //appears as human type, but behavior changes depending on actual instance
        
    }

}

I'm a human, and my stereotype is: I'm going fishing.
I'm a human, and my stereotype is: I'm going shopping.

In the above code within the for loop, we are able to ask for the stereotype of a human, but get different responses each time based on what is the intrinsic type, whether Man or Woman. At the point of calling, we only know that it is a Human - so it appears that the human is morphing each time. There you go, polymorphism!

I hope that example was easy to understand and to illustrate the concept. Polymorphism, at least for me, has been a difficult concept to explain, which is why I resort to easier examples. But if you think about it, the above example could have in reality be implemented as if Man and Woman were inheriting from Human. So let’s extend the example a bit further.

We shall this time change the interface to Hobby. This time we shall have Man and Woman derived from Human. Additionally we will also add a Dog that does not derive from any other type. But we will have each of them implement the interface Hobby. Since they do that, we should be able to call the myStereotype() method on all of them and receive different results based on the intrinsic type.

Full code

package main

import "fmt"

type Hobby interface {
    myStereotype() string
}

type Human struct {

}

func (h Human) myStereotype() string {
    return "I'm a Human, only an abstract concept, and I can have no hobby."
}

type Man struct {
    Human //anonymous class to inherit Human behavior
}

func (m Man) myStereotype() string {
    return "I'm a Man and I'm going fishing."
}

type Woman struct {
    Human //anonymous class to inherit Human behavior
}

func (m Woman) myStereotype() string {
    return "I'm a Woman and I'm going shopping."
}

type Dog struct {
    //does not inherit any other type
}

func (m Dog) myStereotype() string {
    return "bow bow bow, I'm chasing sticks."
}

func main() {
    h := new (Human)
    m := new (Man)
    w := new (Woman)
    d := new (Dog)

    //an array of hobby instances - we don’t need to know whether human or dog
    hobbyArr := [...]Hobby{h, m, w, d} //array of 3 Humans and 1 dog.
    for n, _ := range (hobbyArr ) {

        fmt.Println("My hobby?  Well,", hobbyArr [n].myStereotype())  //appears as Hobby type, but behavior changes depending on actual instance

    }
}

My hobby? Well, I'm a Human, only an abstract concept, and I can have no hobby.
My hobby? Well, I'm a Man and I'm going fishing.
My hobby? Well, I'm a Woman and I'm going shopping.
My hobby? Well, bow bow bow, I'm chasing sticks.

Other topics in this series - Table of Contents