Go Program to Implements for a Struct

Introduction

In Go, methods are functions with a special receiver argument, which allows them to be associated with a specific type, typically a struct. Methods enable you to define behavior related to the data represented by the struct. This guide will demonstrate how to implement methods for a struct in Go.

Problem Statement

Create a Go program that:

Defines a struct type with multiple fields.
Implements methods for the struct to perform operations.
Demonstrates the use of these methods by creating an instance of the struct and calling the methods.

Example:

Struct: Rectangle with fields Width and Height.
Methods: Area to calculate the area and Perimeter to calculate the perimeter of the rectangle.
Output:
```
Area: 20
Perimeter: 18
```

Solution Steps

Define the Struct Type: Define a struct type with the required fields.
Implement Methods for the Struct: Define methods for the struct that operate on its fields.
Import the fmt Package: Use import "fmt" for formatted I/O operations.
Write the Main Function: Define the main function, which is the entry point of every Go program.
Create and Initialize an Instance of the Struct: Use a struct literal to create and initialize an instance of the struct.
Call the Methods and Display the Results: Use the methods defined on the struct to perform operations and display the results.

Go Program

package main

import "fmt"

// Step 1: Define the struct type
type Rectangle struct {
    Width  float64
    Height float64
}

// Step 2: Implement methods for the struct

// Method to calculate the area of the rectangle
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Method to calculate the perimeter of the rectangle
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

/**
 * Go Program to Implement Methods for a Struct
 * Author: https://www.javaguides.net/
 */
func main() {
    // Step 3: Create and initialize an instance of the struct
    rect := Rectangle{
        Width:  5,
        Height: 4,
    }

    // Step 4: Call the methods and display the results
    fmt.Printf("Area: %.2f\n", rect.Area())
    fmt.Printf("Perimeter: %.2f\n", rect.Perimeter())
}

Explanation

Step 1: Define the Struct Type

The Rectangle struct is defined with two fields: Width and Height, both of type float64. This struct represents a rectangle’s dimensions.

Step 2: Implement Methods for the Struct

The Area method is defined with a receiver of type Rectangle. It calculates the area of the rectangle using the formula Width * Height.
```
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
```
The Perimeter method is similarly defined with a receiver of type Rectangle. It calculates the perimeter of the rectangle using the formula 2 * (Width + Height).
```
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}
```

Step 3: Create and Initialize an Instance of the Struct

An instance of the Rectangle struct is created and initialized using a struct literal:
```
rect := Rectangle{
    Width:  5,
    Height: 4,
}
```

Step 4: Call the Methods and Display the Results

The methods Area and Perimeter are called on the rect instance, and the results are printed using fmt.Printf.
```
fmt.Printf("Area: %.2f\n", rect.Area())
fmt.Printf("Perimeter: %.2f\n", rect.Perimeter())
```

Output Example

Example Output:

Area: 20.00
Perimeter: 18.00

Example with Different Values:

rect := Rectangle{
    Width:  7.5,
    Height: 3.2,
}

Output:

Area: 24.00
Perimeter: 21.40

Example with Additional Methods:

If you want to add more methods, such as checking if the rectangle is a square:

func (r Rectangle) IsSquare() bool {
    return r.Width == r.Height
}

fmt.Printf("Is square: %t\n", rect.IsSquare())

Output for a rectangle with Width: 5, Height: 5:

Is square: true

Conclusion

This Go program demonstrates how to implement methods for a struct. It covers basic programming concepts such as defining methods, associating methods with struct types, and using methods to operate on struct fields in Go. This example is useful for beginners learning Go programming and understanding how to encapsulate behavior within data types.