Golang Introduction To Interfaces Complete Guide

Introduction to Interfaces in GoLang

Interfaces in Go provide a way to specify method sets. A type implements an interface if it defines all the methods specified in the interface. Interfaces allow for polymorphism and are a fundamental concept in Go, enabling you to write flexible and reusable code.

Step-by-Step Guide

Step 1: Understanding the Structure of an Interface

An interface in Go is defined using the interface keyword. Let’s start by creating a simple interface that defines a method.

package main

import (
    "fmt"
)

// Define an interface named Shape
type Shape interface {
    Area() float64
    Perimeter() float64
}

func main() {
    // We can now create types that implement this interface
}

In the code above:

• We define an interface called Shape.
• The Shape interface requires Area() and Perimeter() methods to be implemented.

Step 2: Creating Types That Implement the Interface

Let’s create a type Rectangle that implements the Shape interface.

// Define a Rectangle struct
type Rectangle struct {
    Width  float64
    Height float64
}

// Implement Area method for Rectangle
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Implement Perimeter method for Rectangle
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

In the code above:

• We define a struct called Rectangle with Width and Height fields.
• We then implement the Area() and Perimeter() methods for the Rectangle type.
• Since Rectangle now implements all the methods required by the Shape interface, it becomes a type that satisfies Shape.

Step 3: Creating a Function That Uses the Interface

Let’s create a function that takes a Shape and prints its area and perimeter.

// Function to print the area and perimeter of a Shape
func printShapeProperties(shape Shape) {
    fmt.Printf("Area: %.2f\n", shape.Area())
    fmt.Printf("Perimeter: %.2f\n", shape.Perimeter())
}

In the code above:

• We define a function printShapeProperties that takes a parameter of type Shape.
• The function prints the area and perimeter of the shape.

Step 4: Using the Interface

Now let's create instances of the Rectangle type and use them with the Shape interface.

func main() {
    // Create a Rectangle instance
    rect := Rectangle{Width: 10, Height: 5}

    // Use the printShapeProperties function
    fmt.Println("Properties of Rectangle:")
    printShapeProperties(rect)

    // You can also create other shapes that implement Shape interface
    // and use them with printShapeProperties
}

Putting all the code together:

package main

import (
    "fmt"
)

// Define an interface named Shape
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Define a Rectangle struct
type Rectangle struct {
    Width  float64
    Height float64
}

// Implement Area method for Rectangle
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Implement Perimeter method for Rectangle
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Function to print the area and perimeter of a Shape
func printShapeProperties(shape Shape) {
    fmt.Printf("Area: %.2f\n", shape.Area())
    fmt.Printf("Perimeter: %.2f\n", shape.Perimeter())
}

func main() {
    // Create a Rectangle instance
    rect := Rectangle{Width: 10, Height: 5}

    // Use the printShapeProperties function
    fmt.Println("Properties of Rectangle:")
    printShapeProperties(rect)

    // Example of another shape (add more shapes if needed)
}

Step 5: Adding Another Shape

Let’s also define a Circle type that implements the Shape interface.

// Define a Circle struct
type Circle struct {
    Radius float64
}

// Implement Area method for Circle
func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

// Implement Perimeter method for Circle
func (c Circle) Perimeter() float64 {
    return 2 * 3.14159 * c.Radius
}

func main() {
    // Create a Rectangle instance
    rect := Rectangle{Width: 10, Height: 5}

    // Use the printShapeProperties function
    fmt.Println("Properties of Rectangle:")
    printShapeProperties(rect)

    // Create a Circle instance
    circle := Circle{Radius: 7}

    // Use the printShapeProperties function
    fmt.Println("Properties of Circle:")
    printShapeProperties(circle)

    // This demonstrates polymorphism: we can use the same function with different shapes
}

With the Circle type added, you now have the ability to work with different shapes using the same interface Shape.

Conclusion

In this guide, you have learned:

• How to define an interface in Go.
• How to create types that implement an interface.
• How to use functions that operate on the interface type rather than concrete types.
• How to achieve polymorphism in Go using interfaces.