Methods in Golang

In this tutorial, you will learn about the concept of methods in Golang. Methods and functions are not so different while using regular things you can use functions but when functions move into a concept called classes they are termed as methods. You will understand methods, what makes them different from normal functions in this tutorial.

What is a method in Golang?

Go programming language does not support classes in inheritance like other object-oriented programming languages. The Go supports types and methods that allow Golang to perform programs like object-oriented programming languages.

A method is a function with a special receiver argument the receiver appears within its own argument list like (receiver receiver_type) between func keyword and method name. The receiver can be a struct or non-struct type.

How to declare a method in Golang?

In methods, the class concept does not exist instead you can use the struct concept. The functions are brought into a struct that defines a method. Let us understand how to define a method in go program.

Syntax to declare a method


func (receiver receiver_type) method_name(arguments)  return_type {
   return_values
            }

Where

  •   func is the keyword,
  •   the receiver is the name given to receiver_type
  •   receiver_type is the defined struct type
  •   method_name is the name of a method to be evaluated or executed followed by its return type.
  •   The curly braces enclose the return values.  
GO : Methods

Let us understand the method concept with a given program.
The program defines a struct type named emp_details with the following fields Name, Age, Place, Id, salary of string, and integer data types.


// Defining a struct type
type emp_details struct {
    Name    string
    Age int
    Place string
    Id int
    salary int

The defined struct type emp_details has two methods getUserDetails() and  getUserPlace() respectively.


func (e1 emp_details) getUserDetails(){                                  //method 1
    fmt.Println("Name of employee is : ",e1.Name )
    fmt.Println("Age of employee is : ",e1.Age )
    fmt.Println("ID of employee is : ",e1.Id )
}

This is the first method named getUserDetails() with receiver e1 and receiver type emp_details. In the receiver declaration, the instance of emp_details is assigned to variable e1. The curly braces enclose certain print statements which return the values for fields defined in struct type emp_details. The below figure illustrates the functioning of the method.

GO : Methods

Let us know the next method used which is  getUserPlace() .


func (e1 emp_details) getUserPlace() string {   //method 2
return e1.Place
}

As in the same way, the receiver declaration part is composed of (e1 emp_details) where e1 is the variable to which instances of emp_details are assigned. The method receives a return value data type string.

Note: You are passing the receiver (e1 emp_details) to the getUserPlace() method by value which means inside the method you have a copy of all the emp_details.

GO : Methods
  •   The program begins its execution from the main function.
  •   Executes the first print statement showing employee details
  •   e1. getUserDetails ()  control moves to method 1 and performs as we discussed above.
  •   After executing method 1 control switches to method 2 e1.getUserPlace () and processes as we discussed above to display the output.

Golang program to show how to declare and define the method


package main  
import "fmt"
  
// Defining a struct type
type emp_details struct {
    Name    string
    Age int
    Place string
    Id int
    salary int
}

func (e1 emp_details) getUserDetails(){       //method
 fmt.Println("Name of employee is : ",e1.Name )
    fmt.Println("Age of employee is : ",e1.Age )
    fmt.Println("ID of employee is : ",e1.Id )
}

func (e1 emp_details) getUserPlace() string {   //method
return e1.Place
}
  func main() {
     
    //Declaring and Initializing variable of struct type
    e1 := emp_details{"miya", 20,"Mumbai",0067,20000}
 fmt.Println("Given employee details :",e1)
    e1. getUserDetails()
    fmt.Println("employee place is :",e1.getUserPlace())
     
}

Output:

Given employee details : {miya 20 Mumbai 55 20000}
Name of employee is :  miya
Age of employee is :  20
ID of employee is :  55
employee place is : Mumbai

type then it is a method of that type. A function attached to a type with a receiver. This means if you attach a function with a type that function is called a receiver function. The receiver function is the method.
Let us understand with an example. The below program will make you understand what a function is and what is method. How do they differ?

GO : Methods

Table showing difference of method and function

Method function

The method has a receiver argument Eg  

            (m method)

           (receiver receiver_type)

No receiver argument

Different methods with the same receiver name can exist.    

          Eg   func (m method) add() int        

                  func (m method) sub() int         

Different functions with the same name cannot exist   Eg                            func add(x int, y int) int

                   func sub(x, y int) int  

The methods use receivers of either struct or non-struct type. Functions don’t have receivers so no such concept.

Note: Compare the examples in the table with the above picture to better understand the concept

Program to understand the difference between method and function


package main
import "fmt"

type method struct{
 x int
 y int 
}
func (m method) add() int {    //declaring method1
return m.x + m.y

}

func (m method) sub() int {    //declaring method 2
return m.x - m.y

}
func add(x int, y int) int {     //declaring a function function

    return x + y
}

func sub(x, y int) int {       //sub function of omit type

    return x - y
}

func main() {
 m := method{x:3,y:6}     //intitializing
 fmt.Println("The addition result using method is ", m.add())   //calling method 1
    fmt.Println("The addition result using function ",add(10, 5))     //calling function add
    fmt.Println("The subtraction result using method is ", m.sub())   //calling method 2
    fmt.Println("The subtraction result using function is ",sub(10, 5))    // calling function sub
}

Output:


The addition result using method is 
  9
The addition result using function 
  15
The subtraction result using method is 
 -3
The subtraction result using function is 
 5

Note: The above-discussed method is of struct types.

Methods with value type receiver

Go programming language supports methods defined on struct types. The below-given program is defined with a struct of type square using the keyword structinside has the attribute side of the integer data type.

Next, a method is defined which operates on squares. In order to define a method use keywords func followed by parentheses. Inside the parentheses, the method needs to operate is given here it is square. The square is referred to inside the method s. The name of the method is area() with return type as integer. The area() is responsible for computing the area of the square.

Here the s is passed through the method & accessing the attribute side using the dot operator.
Inside the main function call to this method is defined for that we define a variable s for square with its values initialized.

Program with value type receiver


package main
import ("fmt")

type square struct{                //defining a struct type
 side int
    }
    
func (s square ) area() int{     //area of square = side * side
  return s.side* s.side
}

func main() {
 s := square{side : 3} //Declaring and initializing a struct using a struct literal
 fmt.Println("Area of square is :  ",s.area(),"cm^2")  // call to method area()
 
}

Output:


Area of square is:   9 cm^2

Note: The method uses a value type receiver


func (s square ) area() int{
  return s.side* s.side
}

Methods with a pointer receiver

The key difference from the above program is passing a pointer opposite to the value type receiver.
In the below program the main function defines a square s and a pointer to that square and calls the method s_ptr.perimeter () inside the print function which takes a pointer input and prints output as shown below.

GO : Methods

Program to show methods with a pointer


package main
import ("fmt")

type square struct{    //defining a struct type
 side int
    }
    
func (s square ) area() int{     //area of square = side * side
  return s.side* s.side
}

func (s *square) perimeter() int {   //pointer to the struct type square
return 4 * s.side
}

func main() {
 s := square{side : 3} //Declaring and initializing a struct using a struct literal
 fmt.Println("Area of square is :  ",s.area(),"cm^2")
 
 s_ptr := &s  //define a pointer
 fmt.Println("The perimeter of a square is 4 * sides :", s_ptr.perimeter())
 
}

Output:


Area of square is :   9 cm^2
The perimeter of a square is 4 * sides : 12