Polymorphism is the ability of a message to be displayed in more than one form. Polymorphism is considered one of the important features of Object-Oriented Programming and can be achieved during either runtime or compile time. Golang is a light-object-oriented language and supports polymorphism through interfaces only. Let us first understand the interfaces by the following example
Example 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 ,
}
// The Figure interface can hold rectangle and square type as they both implements the interface
var f1 Figure = rectangle
var f2 Figure = square
// printing the calculated result
fmt.Printf( "Area of rectangle: %.3f unit sq.\n" , f1.Area())
fmt.Printf( "Area of square: %.3f unit sq.\n" , f2.Area())
} |
Output:
Area of rectangle: 128.625 unit sq. Area of square: 225.000 unit sq.
Objects of different types are treated in a consistent way, as long as they stick to a single interface, which is the essence of polymorphism. Variable declared in an interface are of interface type. They can take whichever value implements the interface which helps interfaces to achieve polymorphism in the Golang. The following example explains the concept of polymorphism:
Example 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)
} |
Output:
Total Time is 2060 minutes.