How Golang Interfaces Differ from Other Languages

In this article, I want to talk about how interfaces in Go are different from those in other languages like Java, C#, and TypeScript. If you're used to working with those languages, you'll notice Go does things a little differently—sometimes in ways that make life easier, and other times in ways that might take some getting used to.

Implicit Implementation vs. Explicit Contracts

One of the biggest things that sets Go apart is how interfaces are implemented. Unlike Java, C#, or TypeScript, where you have to explicitly declare that a class implements an interface, Go does this implicitly. If a type has the required methods, it satisfies the interface—no implements or extends needed.

Example in Go (Implicit Implementation)

package main
import "fmt"

// Interface definition
 type Speaker interface {
     Speak()
 }

// Struct that satisfies the interface implicitly
 type Person struct {}

func (p Person) Speak() {
    fmt.Println("Hello!")
}

func main() {
    var s Speaker = Person{} // No explicit declaration needed
    s.Speak()
}

Example in Java (Explicit Implementation)

interface Speaker {
    void speak();
}

class Person implements Speaker {
    public void speak() {
        System.out.println("Hello!");
    }
}

public class Main {
    public static void main(String[] args) {
        Speaker s = new Person();
        s.speak();
    }
}

In Java, you have to use implements to say "Hey, I'm following this interface!" In Go, you just implement the methods, and the compiler takes care of the rest.

No Interface Inheritance

If you're used to interfaces inheriting from other interfaces, like in Java and C#, Go does things differently. Instead of inheritance, Go allows interface composition—meaning you can combine smaller interfaces into larger ones without creating deep inheritance trees.

Example in Go (Interface Composition)

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

This isn’t the same as inheritance—ReadWriter just says, “I need both Reader and Writer behaviors.” It's a much simpler and cleaner way to structure interfaces.

Interfaces with Zero Methods (Empty Interfaces)

Go has something called an empty interface (interface{}), which might seem weird if you’re coming from Java or C#. It’s basically a way to say, "I can accept any type."

Example in Go (Empty Interface)

func PrintAnything(v interface{}) {
    fmt.Println(v)
}

In Java or C#, you’d use generics to achieve something similar, but Go’s empty interfaces make it super easy to write flexible code without overcomplicating things.

Duck Typing without Performance Overhead

Go's implicit interfaces give you duck typing ("if it quacks like a duck, it’s a duck") at compile time, meaning you don’t pay the performance penalty that comes with runtime reflection (which happens in dynamically typed languages like Python and JavaScript). I think this is one of the best things about Go—it gives you flexibility without slowing things down.

No Generics (Until Go 1.18)

Before Go 1.18, Go didn't have generics, so interfaces were often used to add flexibility. Now that generics are here, some of those use cases have shifted. If you're just getting into Go, I'd recommend learning both interfaces and generics, since they each have their place.

Conclusion

I hope this gave you a good idea of how Go’s interfaces are different from those in other languages. To sum it up:

• Go uses implicit implementation, so you don’t have to explicitly say a type implements an interface.

• Instead of inheritance, Go uses interface composition to build larger interfaces from smaller ones.

• Empty interfaces let you work with any type easily.

• You get duck typing without runtime overhead, which keeps things efficient.

• Before generics, interfaces did a lot of heavy lifting, but now they work alongside generics for flexible, type-safe code.

If you're coming from an OOP-heavy background, Go’s interface system might feel different at first, but once you get used to it, you'll see how it encourages writing cleaner, more modular code. Happy coding!