How to use interfaces in go?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, interfaces provide a powerful way to define and work with abstract types. Interfaces are a cornerstone of Go's type system and enable polymorphism, allowing different types to be used interchangeably as long as they implement the same interface methods. This guide explains how to define and use interfaces in Go, providing practical examples to illustrate their functionality.
Using Interfaces in Go
Defining an Interface
An interface in Go is a type that specifies a contract by defining methods that a type must implement. The interface itself does not contain any implementation, only method signatures. Types that implement these methods satisfy the interface.
Example:
package main

import "fmt"

// Defining an interface
type Speaker interface {
    Speak() string
}

// Implementing the interface with a type
type Person struct {
    Name string
}

func (p Person) Speak() string {
    return "Hello, my name is " + p.Name
}

func main() {
    var speaker Speaker
    person := Person{Name: "Alice"}
    speaker = person // Person implements the Speaker interface
    fmt.Println(speaker.Speak()) // Output: Hello, my name is Alice
}

Implementing an Interface
To implement an interface, a type must provide concrete implementations for all the methods declared in the interface. There is no explicit declaration needed to indicate that a type implements an interface; the implementation is implicit.
Example:
package main

import "fmt"

// Defining an interface
type Shape interface {
    Area() float64
}

// Implementing the interface with a type
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func main() {
    var shape Shape
    rect := Rectangle{Width: 10, Height: 5}
    shape = rect // Rectangle implements the Shape interface
    fmt.Println("Area of rectangle:", shape.Area()) // Output: Area of rectangle: 50
}

Type Assertion
Type assertion allows you to retrieve the underlying value of an interface and check its type. It is useful for determining the concrete type of an interface value.
Example:
package main

import "fmt"

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof"
}

func main() {
    var animal Animal = Dog{}

// Type assertion to determine the concrete type
    if dog, ok := animal.(Dog); ok {
        fmt.Println("Animal is a Dog with sound:", dog.Speak())
    } else {
        fmt.Println("Animal is not a Dog")
    }
}

Type Switch
A type switch allows you to handle different types that an interface value might hold, using multiple type assertions.
Example:
package main

import "fmt"

type Printer interface {
    Print() string
}

type Document struct {
    Title string
}

func (d Document) Print() string {
    return "Document title: " + d.Title
}

type Image struct {
    Filename string
}

func (i Image) Print() string {
    return "Image file: " + i.Filename
}

func printContent(p Printer) {
    switch v := p.(type) {
    case Document:
        fmt.Println("Printing document:", v.Print())
    case Image:
        fmt.Println("Printing image:", v.Print())
    default:
        fmt.Println("Unknown type")
    }
}

func main() {
    doc := Document{Title: "Go Programming"}
    img := Image{Filename: "go_logo.png"}

printContent(doc) // Output: Printing document: Document title: Go Programming
    printContent(img) // Output: Printing image: Image file: go_logo.png
}

Practical Examples
Example 1: Using Interfaces for Polymorphism
Interfaces allow you to use different types interchangeably when they share the same method signature, which is useful for designing flexible and reusable code.
package main

import "fmt"

type Vehicle interface {
    Move() string
}

type Car struct{}

func (c Car) Move() string {
    return "Car moves on roads"
}

type Boat struct{}

func (b Boat) Move() string {
    return "Boat moves on water"
}

func describe(v Vehicle) {
    fmt.Println(v.Move())
}

func main() {
    car := Car{}
    boat := Boat{}

describe(car) // Output: Car moves on roads
    describe(boat) // Output: Boat moves on water
}

Example 2: Using Interfaces for Dependency Injection
Interfaces enable dependency injection, where you can inject different implementations into functions or methods, making them more flexible and testable.
package main

import "fmt"

type Database interface {
    Connect() string
}

type MySQL struct{}

func (m MySQL) Connect() string {
    return "Connected to MySQL"
}

type PostgreSQL struct{}

func (p PostgreSQL) Connect() string {
    return "Connected to PostgreSQL"
}

func setupDatabase(db Database) {
    fmt.Println(db.Connect())
}

func main() {
    mysql := MySQL{}
    postgres := PostgreSQL{}

setupDatabase(mysql)    // Output: Connected to MySQL
    setupDatabase(postgres) // Output: Connected to PostgreSQL
}

Conclusion
Interfaces in Go are a powerful feature that facilitates polymorphism and abstraction. By defining interfaces and implementing them with different types, you can create flexible and reusable code. Type assertions and type switches provide additional functionality to work with interface values. Understanding and using interfaces effectively is key to leveraging Go's type system and designing robust applications.

How to use interfaces in go?

Similar Questions