Java vs Go Generics: Syntax, Constraints, and Practical Differences

Generics are a powerful feature for achieving type‑safe code reuse. This article examines how Java, a mature object‑oriented language, and Go, a newer language that introduced generics in version 1.18, implement generics.

Go generics syntax

In Go, type parameters are declared with the type keyword and constrained using any or more specific interfaces. Example:

func Print[T any](t T) {
    fmt.Printf("printing type: %T
", t)
}

type Tree[T any] struct {
    left, right *Tree[T]
    data        T
}

These definitions allow functions and structs to operate on any type while preserving compile‑time type safety.

Java generics syntax

Java uses angle brackets <T> to declare type parameters. Example:

public static <T> void print(T t) {
    System.out.println("printing type: " + t.getClass().getName());
}

class Tree<T> {
    private Tree<T> left, right;
    private T data;
}

Java’s type system includes a unified object hierarchy where every type extends java.lang.Object, allowing implicit constraints.

Key differences

Go requires explicit constraints (e.g., T any), while Java infers Object as the default bound.

Go does not support type switches on generic parameters without a concrete constraint, leading to compile‑time errors such as cannot use type switch on type parameter value t.

Java can perform a switch on generic values (with pattern matching in newer releases), but older versions lack this feature.

Type constraints

In Go, T any means the type parameter implements the empty interface, but it can be further constrained to specific types or interfaces, e.g.:

func PrintInt64[T int64](t T) {
    fmt.Printf("%v
", t)
}

Java achieves similar constraints with bounded type parameters, such as <T extends Number & Closeable>.

Union types

Go permits union type sets like T int64|float64, but they cannot mix interfaces with concrete types. Java only allows union‑like constraints via interfaces (e.g., <T extends Closeable & Flushable>).

Variance

Go’s generics do not support covariance or contravariance; type arguments are unrelated regardless of subtype relationships. Java provides wildcard variance with ? extends and ? super to express covariant and contravariant relationships.

Conclusion

Both languages support generics, but Go emphasizes explicit, simple constraints and avoids variance, while Java offers a richer type hierarchy and more flexible bounded type parameters. Understanding these differences helps developers choose appropriate patterns and avoid compilation pitfalls when writing generic code in either language.