Golang: Interfaces

 

Go by Example: Interfaces (All are there go through well )

Interfaces are named collections of method signatures.
	package main
	import ( "fmt" "math" )
Here’s a basic interface for geometric shapes.	type geometry interface { area() float64 perim() float64 }
For our example we’ll implement this interface on rect and circle types.	type rect struct { width, height float64 } type circle struct { radius float64 }
To implement an interface in Go, we just need to implement all the methods in the interface. Here we implement geometry on rects.	func (r rect) area() float64 { return r.width * r.height } func (r rect) perim() float64 { return 2*r.width + 2*r.height }
The implementation for circles.	func (c circle) area() float64 { return math.Pi * c.radius * c.radius } func (c circle) perim() float64 { return 2 * math.Pi * c.radius }
If a variable has an interface type, then we can call methods that are in the named interface. Here’s a generic measure function taking advantage of this to work on any geometry.	func measure(g geometry) { fmt.Println(g) fmt.Println(g.area()) fmt.Println(g.perim()) }
	func main() { r := rect{width: 3, height: 4} c := circle{radius: 5}
The circle and rect struct types both implement the geometry interface so we can use instances of these structs as arguments to measure.	measure(r) measure(c) }

$ go run interfaces.go {3 4} 12 14 {5} 78.53981633974483 31.41592653589793

Ref: https://gobyexample.com/interfaces

A nice example =: 

package main

import (  
    "fmt"
)

type SalaryCalculator interface {  
    CalculateSalary() int
}

type Permanent struct {  
    empId    int
    basicpay int
    pf       int
}

type Contract struct {  
    empId    int
    basicpay int
}

type Freelancer struct {  
    empId       int
    ratePerHour int
    totalHours  int
}

//salary of permanent employee is sum of basic pay and pf
func (p Permanent) CalculateSalary() int {  
    return p.basicpay + p.pf
}

//salary of contract employee is the basic pay alone
func (c Contract) CalculateSalary() int {  
    return c.basicpay
}

//salary of freelancer
func (f Freelancer) CalculateSalary() int {  
    return f.ratePerHour * f.totalHours
}

/*
total expense is calculated by iterating through the SalaryCalculator slice and summing  
the salaries of the individual employees  
data types can be refereed by interface like below  <<< = V.V.V */
func totalExpense(s []SalaryCalculator) {  
    expense := 0
    for _, v := range s {
        expense = expense + v.CalculateSalary()
    }
    fmt.Printf("Total Expense Per Month $%d", expense)
}

func main() {  
    pemp1 := Permanent{
        empId:    1,
        basicpay: 5000,
        pf:       20,
    }
    pemp2 := Permanent{
        empId:    2,
        basicpay: 6000,
        pf:       30,
    }
    cemp1 := Contract{
        empId:    3,
        basicpay: 3000,
    }
    freelancer1 := Freelancer{
        empId:       4,
        ratePerHour: 70,
        totalHours:  120,
    }
    freelancer2 := Freelancer{
        empId:       5,
        ratePerHour: 100,
        totalHours:  100,
    }
    employees := []SalaryCalculator{pemp1, pemp2, cemp1, freelancer1, freelancer2}
    totalExpense(employees)