Golang | Polymorphism Using Interfaces

The word polymorphism means having many forms. Or in other words, we can define polymorphism as the ability of a message to be displayed in more than one form. Or in technical term polymorphism means same method name (but different signatures) being uses for different types. For example, a woman at the same time can have different characteristic. Like a mother, a wife, a sister, an employee, etc. So the same person posses different behavior in different situations. This is called polymorphism.
In Go language, we cannot achieve polymorphism with the help of classes because Go language does not support classes but can achieve by using interfaces. As we already know that the interfaces are implicitly implemented in Go. So, when we create an interface and other types want to implement that interface, then those types use that interface with the help of the methods defined in the interface without knowing the type. In an interface, a variable of an interface type can contain any value which implements the interface. This property helps interfaces to achieve polymorphism in the Go language. Let us discuss with the help of an example:

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Go program to illustrate the concept
// of polymorphism using interfaces
package main
  
import "fmt"
  
// Interface
type employee interface {
    develop() int
    name() string
}
  
// Structure 1
type team1 struct {
    totalapp_1 int
    name_1     string
}
  
// Methods of employee interface are
// implemented by the team1 structure
func (t1 team1) develop() int {
    return t1.totalapp_1
}
  
func (t1 team1) name() string {
    return t1.name_1
}
  
// Structure 2
type team2 struct {
    totalapp_2 int
    name_2     string
}
  
// Methods of employee interface are
// implemented by the team2 structure
func (t2 team2) develop() int {
    return t2.totalapp_2
}
  
func (t2 team2) name() string {
    return t2.name_2
}
  
func finaldevelop(i []employee) {
  
    totalproject := 0
    for _, ele := range i {
  
        fmt.Printf("\nProject environment = %s\n ", ele.name())
        fmt.Printf("Total number of project %d\n ", ele.develop())
        totalproject += ele.develop()
    }
    fmt.Printf("\nTotal projects completed by "+
        "the company = %d", totalproject)
}
  
// Main function
func main() {
  
    res1 := team1{totalapp_1: 20,
        name_1: "Android"}
  
    res2 := team2{totalapp_2: 35,
        name_2: "IOS"}
  
    final := []employee{res1, res2}
    finaldevelop(final)
  
}

chevron_right


Output:



Project environment = Android
 Total number of project 20
 
Project environment = IOS
 Total number of project 35
 
Total projects completed by the company = 55

Explanation: In the above example, we have an interface name as an employee. This interface contains two methods, i.e, develop() and name() method, here, develop() method returns the total number of projects and name() method return the name of the environment in which they are developed.

Now we have two structures, i.e, team1, and team2. Both the structures contain two-two fields, i.e, totalapp_1 int, name_1 string, totalapp_2 int, and name_2 string. Now, these structures (i.e, team1 and team2) are implementing the methods of the employee interface.

After that, we create a function named as finaldevelop() which returns the total number of projects developed by the company. It accepts a slice of employee interfaces as an argument and calculates the total number of the projects developed by the company by iterating over the slice and call develop() method on each of its elements. It also displays the environment of the project by calling the name() method. According to the concrete type of the employee interface, different develop() and name() methods will be called. So, we achieved polymorphism in the finaldevelop() function.

If you add another team in this program which implements employee interface this finaldevelop() function will calculate the total number of the projects developed by the company without any change due to polymorphism.



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.