Interface Usage Golang vs Java

VibhorDubey — Mon, 06 Oct 2025 11:12:59 +0000

While experimenting with interfaces in Java and Golang, I noticed some fundamental differences in how each language approaches abstraction. This post summarizes those insights for anyone curious about both worlds.

A. Definition and Declaration

In Java:

An interface is an explicit construct declared using the interface keyword.
Classes must explicitly declare that they implement an interface using the implements keyword.

interface Shape {
    void draw();
}

class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

In Go:

type Shape interface {
    Draw()
}

type Circle struct{}

func (c Circle) Draw() {
    fmt.Println("Drawing Circle")
}

An interface is also declared using the interface keyword, but implementation is implicit.

A type (struct) implements an interface automatically if it defines all the methods in that interface.

👉 Key difference:
In Java, a class must declare that it implements an interface.
In Go, a type implements an interface implicitly — no need to declare it.

B. Method Implementation and Type Checking

Java:

Statically checked at compile time.
If a class claims to implement an interface but doesn’t define all methods, compilation fails.
Strongly tied to inheritance hierarchy.

Go:

Also statically checked, but duck typing applies.
As long as a type has all methods required by an interface, it’s valid.
Promotes composition over inheritance.

C. Multiple Interfaces and Composition

Java:

A class can implement multiple interfaces.
Interface composition is explicit (using extends).

interface A { void a(); }
interface B { void b(); }
interface C extends A, B { void c(); }

Go:

Interfaces are composable — you can embed one interface into another.
This is done by embedding rather than inheritance.

type A interface { a() }
type B interface { b() }
type C interface {
    A
    B
    c()
}

👉 Go favors composition, while Java relies on inheritance.

D. Default Methods

Java:

Since Java 8, interfaces can have default and static methods with implementation.

interface Shape {
    default void info() {
        System.out.println("I am a shape");
    }
}

Go:

Interfaces cannot have any implementation — they are purely abstract.
Behavior must be defined on concrete types.

E. Nil and Zero Values

Java:

null can represent an interface reference with no object.

Go:

The zero value of an interface is nil.
If an interface variable is nil, calling a method on it will panic.

F. Performance and Memory

Java:

Uses JVM vtables for dynamic dispatch.
Garbage collection handles object lifetime.

Go:

Uses interface value pairs (type + data pointer).
Interface dispatch is efficient but slightly slower than direct method calls.

Hoping this article helped in understanding the nuances of interface in Java & Golang.

Happy Coding - onwards and upwards 🚀

Generics In Golang

VibhorDubey — Mon, 09 Jan 2023 12:17:59 +0000

Generics in Go got introduced in release 1.18.

What are generics?

Generics is a mechanism through which we can pass any type of value in a function.

What were the issues prior to Go version 1.18?

package main

import "fmt"

func main() {
    stringObject := "Hello"
    floatObject := 3.14
    intObject := 7

    assertType(stringObject)
    assertType(intObject)
    assertType(floatObject)
}

func assertType(object interface{}) {
    switch object.(type) {
    case string:
        fmt.Println("Received Type:", object.(string))
    case int:
        fmt.Println("Received Type:", object.(int))
    default:
        fmt.Println("Unknown Type")
    }
}

So, every time we need to infer the type if we infer it with wrong datatype it will result into panic. Let's see another simple example.

package main

import "fmt"

func main() {
    stringObject := "Hello"
    printValue(stringObject)
}

func printValue(object interface{}) {
    fmt.Println(object.(int))
}

Here, we're trying to infer the string as int so it will result in a panic. So if we don't use the correct type it will cause panic in our program.

3. Genrics Code Example?

A. Any
Let's see our first example. Where we'll pass any value in function be it array, int, string.

package main

import (
    "fmt"
)

func assertType(T any) {
    fmt.Println(T)
}
func assertTypeArray[T any](arrayObject []T) []T {
    for i := range arrayObject {
        fmt.Println(i)
    }
    return arrayObject
}
func main() {
    assertType("Hello")
    assertType(12.32)

    array := []int{1, 2, 3}
    arrayObject := assertTypeArray(array)
    fmt.Println(arrayObject)
}

B. Predefined constraints.

We can define the datatypes in interface like Integer, Float then embed inside Number interface. Using predefined constraint we can restrict the input.

package main

import (
    "fmt"
)

type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

type Float interface {
    ~float32 | ~float64
}

type Number interface {
    Integer | Float
}

func Min[T Number](x, y T) T {
    if x < y {
        return x
    }
    return y
}

type IntType int64

func main() {
    x, y := 1, 3
    a, b := 1.1, 4.5
    k, v := IntType(-12344), IntType(12)
    fmt.Println(Min(x, y))
    fmt.Println(Min(a, b))
    fmt.Println(Min(k, v))
}

DEV Community: VibhorDubey

Interface Usage Golang vs Java

A. Definition and Declaration

B. Method Implementation and Type Checking

C. Multiple Interfaces and Composition

D. Default Methods

E. Nil and Zero Values

F. Performance and Memory

Generics In Golang