Polimorfismo en GoLang

El polimorfismo es la capacidad de un mensaje para mostrarse en más de una forma. El polimorfismo se considera una de las características importantes de la programación orientada a objetos y se puede lograr durante el tiempo de ejecución o de compilación. Golang es un lenguaje orientado a objetos ligero y admite polimorfismo solo a través de interfaces . Entendamos primero las interfaces con el siguiente ejemplo:
Ejemplo 1:
 

// Golang program to illustrate the
// concept of interfaces
package main
 
import (
    "fmt"
)
 
// defining an interface
type Figure interface{
 
    Area() float64
}
 
// declaring a struct
type Rectangle struct{
     
    // declaring struct variables
    length float64
    width float64
}
 
// declaring a struct
type Square struct{
     
    // declaring struct variable
    side float64
}
 
// function to calculate
// area of a rectangle
func (rect Rectangle) Area() float64{
 
    // Area of rectangle = l * b
    area := rect.length * rect.width
    return area
}
 
// function to calculate
// area of a square
func (sq Square) Area() float64{
     
    // Area of square = a * a
    area := sq.side * sq.side
    return area
}
 
// main function
func main() {
     
    // declaring a rectangle instance
    rectangle := Rectangle{
     
        length: 10.5,
        width: 12.25,
    }
     
    // declaring a square instance
    square := Square{
     
        side: 15.0,
    }
     
    // printing the calculated result
    fmt.Printf("Area of rectangle: %.3f unit sq.\n", rectangle.Area())
    fmt.Printf("Area of square: %.3f unit sq.\n", square.Area())
}

Producción: 
 

Area of rectangle: 128.625 unit sq.
Area of square: 225.000 unit sq.

Los objetos de diferentes tipos se tratan de manera coherente, siempre que se adhieran a una sola interfaz, que es la esencia del polimorfismo. Las variables declaradas en una interfaz son de tipo interfaz. Pueden tomar cualquier valor que implemente la interfaz que ayude a las interfaces a lograr el polimorfismo en el Golang. El siguiente ejemplo explica el concepto de polimorfismo:
Ejemplo 2:
 

// Golang program to illustrate the
// concept of polymorphism
package main
 
import (
    "fmt"
)
 
// defining an interface
type Reading interface{
 
    // declaring interface method
    reading_time() int
}
 
// declaring a struct
type Book struct{
     
    // declaring struct variables
    name string
    page_count int
}
 
// declaring a struct
type Newspaper struct{
 
    // declaring struct variables
    name string
    page_count int
}
 
// declaring a struct
type Magazine struct{
 
    // declaring struct variables
    name string
    page_count int
}
 
// function to calculate reading
// time for book
func (book Book) reading_time() int {
     
    // taking average speed
    // of 10 mins per page
    read_time := 10 * book.page_count
    return read_time
}
 
// function to calculate reading
// time for newspaper
func (newspaper Newspaper) reading_time() int {
 
    // taking average speed
    // of 30 mins per page
    read_time := 30 * newspaper.page_count
    return read_time
}
 
// function to calculate reading
// time for magazine
func (magazine Magazine) reading_time() int {
     
    // taking average speed
    // of 5 mins per page
    read_time := 5 * magazine.page_count
    return read_time
}
 
// function to calculate reading time
func calcReadingTime(ReadingTime []Reading) int {
 
        totalTime := 0
     
    // looping through elements
    // of the Reading array   
        for _, t := range ReadingTime {
         
        // run time polymorphism, call to
        // method depends on object being
        // referred at run time
            totalTime += t.reading_time()
        }
     
        return totalTime
}
 
// main function
func main() {
     
    // declaring a book instance
    book1 := Book{
        name: "Goosebumps",
        page_count: 150,
    }
     
    // declaring a newspaper instance
    newspaper1 := Newspaper{
        name: "TOI",
        page_count: 12,
    }
     
    // declaring a magazine instance
    magazine1 := Magazine{
        name: "Forbes",
        page_count: 40,
    }
     
    // array of type Reading interface
    ReadingTime := []Reading{book1, newspaper1, magazine1}
     
    // total reading time calculated
        totalTime := calcReadingTime(ReadingTime)
     
    // Printing total time for reading
        fmt.Printf("Total Time is %d minutes.\n", totalTime)
}

Producción: 
 

Total Time is 2060 minutes.