Polymorphism in GoLang

Polymorphism is the ability of a message to be displayed in more than one form. Polymorphism is considered as one of the important features of Object-Oriented Programming and can be achieved during either at 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:

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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 which implements the interface which helps interfaces to achieve polymorphism in the Golang. The following example explains the concept of polymorphism:

Example 2:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 polymophism, 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)
}

chevron_right


Output:

Total Time is 2060 minutes.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.