Back to series
· 14 min read

Differences Between Go and Java


I. What Are Go and Java?

Go (Golang) is an open-source programming language officially released by Google in 2009, with the design goals of simplifying large-scale software development and improving compilation speed, runtime efficiency, and concurrency handling.

Java is an object-oriented programming language officially released by Sun Microsystems in 1995; its main distributions and ecosystem development are now led by Oracle. Java uses the JVM (Java Virtual Machine) as its core runtime foundation, emphasizing cross-platform capability, type safety, and a mature enterprise-grade development system.

Both languages support static type checking, garbage collection, concurrent programming, and large-scale backend system development, but they differ markedly in language features, runtime architecture, and engineering practices.

1. Main Features of Go

  • Concise syntax: Fewer keywords; the syntax design emphasizes consistency.
  • Fast compilation: The toolchain is highly integrated and can usually produce a native executable quickly.
  • Built-in concurrency: Goroutines and Channels provide lightweight concurrent programming capability.
  • Garbage collection: The runtime manages the memory of most dynamically allocated objects.
  • Implicit interface implementation: A type automatically implements an interface as long as it satisfies the interface's method set.
  • Simple deployment: A common deployment approach is to distribute the compiled executable directly.

Go code example:

package main

import "fmt"

func main() {
    message := "Hello, Go!"
    fmt.Println(message)
}

2. Main Features of Java

  • Object-oriented: Supports classes, inheritance, interfaces, encapsulation, and polymorphism.
  • JVM runtime environment: Bytecode can run on JVMs across different platforms.
  • Static type system: Supports generics, interfaces, annotations, and rich type constraints.
  • Mature concurrency framework: Provides mechanisms such as threads, thread pools, locks, concurrent collections, and virtual threads.
  • Garbage collection: The JVM manages object memory and garbage collection.
  • Enterprise-grade ecosystem: Has mature technology stacks such as Spring, Hibernate, Maven, and Gradle.

Java code example:

public class Main {
    public static void main(String[] args) {
        String message = "Hello, Java!";
        System.out.println(message);
    }
}

II. Core Differences Between Go and Java

Both Go and Java are statically typed languages, but Go places more emphasis on the simplicity of the language itself and system-level engineering efficiency, while Java provides richer object-oriented capabilities and a runtime ecosystem.

Comparison Dimension Go Java
Language type Statically typed, compiled language Statically typed, usually compiled to bytecode
Design philosophy Simple, efficient, concurrency-friendly Object-oriented, cross-platform, mature ecosystem
Code organization Package Class, Package, Module
Object orientation Achieved through type composition and methods Native support for classes, inheritance, and polymorphism
Inheritance Does not support traditional class inheritance Supports class inheritance
Interface implementation Implicit implementation Explicit implements declaration
Generics Supported since Go 1.18 Supported since Java 5
Concurrency model Goroutine, Channel Thread, Executor, Virtual Thread, etc.
Memory management Go Runtime garbage collection JVM garbage collection
Compilation output Usually generates a native executable Usually generates JVM bytecode
Runtime environment Go Runtime runs alongside the program Requires a compatible JVM
Deployment method Commonly a standalone executable Usually deployed as a JAR, container, or application package
Typical scenarios Cloud-native, microservices, network services Enterprise applications, financial systems, large business platforms

Note that the "compiled" nature of Go and Java is not a simple binary opposition. Go usually uses a compiler to generate machine code for the target platform; Java usually generates JVM bytecode first, which is then interpreted by the JVM or optimized through JIT compilation.

III. Differences in Type Systems

Both Go and Java use static type systems, but their type design and type composition approaches differ considerably.

1. Go: Static Typing and Type Inference

Go is a statically typed language; the types of variables are determined at compile time.

You can declare variable types explicitly:

var age int = 25
var name string = "Alice"

You can also use short variable declarations to let the compiler infer the type:

age := 25
name := "Alice"

Although using := means you don't have to write the type explicitly, the variable's static type is still fixed.

For example:

age := 25

// compile error
// age = "Alice"

Go does not allow a string to be assigned directly to a variable already declared as int.

2. Java: Static Types and Local Variable Type Inference

Java likewise uses a static type system.

The traditional way:

int age = 25;
String name = "Alice";

Starting with Java 10, local variables can use var for type inference:

var age = 25;
var name = "Alice";

Here, var does not mean Java has become a dynamically typed language.

The compiler still determines the variable's static type from the initializer expression.

var age = 25;

// compile error
// age = "Alice";

3. Handling Null Values

Both Go and Java have mechanisms related to null values, but they express them differently.

Go uses nil to represent the zero value of specific types such as pointers, interfaces, slices, maps, channels, and functions.

var name *string

fmt.Println(name == nil) // true

Java uses null to indicate that a reference does not point to an object:

String name = null;

System.out.println(name == null); // true

Java can also use Optional<T> to explicitly express a return value that may be absent:

Optional<String> name = Optional.empty();

Note the following:

  • Go's nil cannot be used with all types.
  • Java's null can be assigned to reference types, but not to primitive types.
  • Go interfaces combine a dynamic type and a value internally, and an interface value is not necessarily equal to nil only when both its internal type and value are empty.
  • Java's Optional is an API design tool; it cannot eliminate all null pointer problems at the language level.

4. Basic Types and the Object Model

Go's basic types include:

  • Boolean type: bool
  • Integer types: int, int8, int16, int32, int64
  • Unsigned integers: uint, uint8, etc.
  • Floating-point types: float32, float64
  • Complex types: complex64, complex128
  • String type: string

Java's primitive types include:

  • boolean
  • byte
  • short
  • int
  • long
  • float
  • double
  • char

Java also provides corresponding wrapper types, such as Integer, Long, and Boolean.

Go does not have a unified primitive wrapper system like Java's. In Go, structs, arrays, slices, maps, interfaces, and pointers together form its composite data model.

IV. Differences in Object-Oriented Design

Both Go and Java support organizing data and behavior together, but the two understand object orientation differently.

Java adopts a class-centric object-oriented model, while Go implements object-oriented design through structs, methods, interfaces, and composition.

1. Java: Class-Centric

Java uses class to define classes, and object instances carry state and behavior.

class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public void sayHello() {
        System.out.println("Hello, " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        User user = new User("Alice");
        user.sayHello();
    }
}

Java's typical object-oriented features include:

  • Encapsulation: manage member visibility through access control.
  • Inheritance: implement class inheritance via extends.
  • Polymorphism: achieved through method overriding and dynamic dispatch.
  • Abstraction: define behavioral contracts through abstract classes and interfaces.

2. Go: Structs and Methods

Go has no class in the traditional sense; instead, it uses struct to define data structures.

package main

import "fmt"

type User struct {
    Name string
}

func (u User) SayHello() {
    fmt.Println("Hello,", u.Name)
}

func main() {
    user := User{Name: "Alice"}
    user.SayHello()
}

Go associates methods with a specific type through method receivers.

Method receivers can be value receivers or pointer receivers:

type Counter struct {
    Value int
}

func (c Counter) Read() int {
    return c.Value
}

func (c *Counter) Increment() {
    c.Value++
}

A value receiver typically operates on a copy of the receiver's value; a pointer receiver can modify the original object, and is also common with large structs or when the method set needs to remain consistent.

3. Inheritance and Composition

Java supports class inheritance:

class Animal {
    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking");
    }
}

Dog can inherit the members of Animal and extend behavior on top of that.

Go does not support traditional class inheritance and typically uses struct embedding to achieve composition:

type Animal struct {
    Name string
}

func (a Animal) Eat() {
    fmt.Println(a.Name, "is eating")
}

type Dog struct {
    Animal
}

func main() {
    dog := Dog{
        Animal: Animal{Name: "Buddy"},
    }

    dog.Eat()
}

Here Dog embeds Animal, and can access its methods through promotion.

But this does not mean Dog is a subclass of Animal. Struct embedding in Go is a composition mechanism; it does not automatically establish the subtype relationship found in traditional object-oriented inheritance.

4. How Interfaces Are Implemented

Go and Java differ significantly in their interface mechanisms.

Java requires explicitly declaring that an interface is implemented:

interface Animal {
    void eat();
}

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

Go uses implicit interface implementation:

type Animal interface {
    Eat()
}

type Dog struct{}

func (d Dog) Eat() {
    fmt.Println("Dog is eating")
}

As long as the method set of Dog satisfies the requirements of the Animal interface, it implements that interface — no explicit declaration is needed.

This design reduces coupling between types and allows interfaces to be defined on the consumer side.

5. Comparing the Two Design Approaches

Comparison Dimension Go Java
Core Structure Struct Class
Methods Method receivers Class member methods
Class Inheritance Not supported Supported
Code Reuse Composition, embedding Inheritance, composition
Interface Implementation Implicit Explicit
Polymorphism Through interfaces Through interfaces and inheritance
Encapsulation Package-level visibility rules private, protected, public, etc.
Abstract Classes No corresponding language construct Supported

V. Differences in Generic Mechanisms

Generics are used to write data structures and algorithms that can handle multiple types while retaining static type constraints.

Both Java and Go support generics, but they differ in when generics were introduced, in type constraints, and in implementation approach.

1. Go Generics

Go has officially supported generics since version 1.18.

package main

import "fmt"

func Print[T any](value T) {
    fmt.Println(value)
}

func main() {
    Print[int](100)
    Print[string]("Hello")
}

Here:

  • T is a type parameter.
  • any is an alias for interface{}, meaning no additional method constraints are imposed.
  • When calling, the type can be specified explicitly or determined through type inference.

Go also supports custom type constraints:

type Number interface {
    ~int | ~int64 | ~float64
}

func Add[T Number](a, b T) T {
    return a + b
}

Here, ~ indicates that the underlying type satisfies the corresponding type constraint.

Go generics express the constraints of reusable algorithms mainly through type parameters and type sets.

2. Java Generics

Java has supported generics since Java 5.

public class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

Using a generic class:

Box<Integer> box = new Box<>();

box.set(100);

Integer value = box.get();

Java generics also support upper-bounded and lower-bounded wildcards:

public static <T extends Number> double sum(
    List<T> values
) {
    double result = 0;

    for (T value : values) {
        result += value.doubleValue();
    }

    return result;
}

An important characteristic of Java generics is type erasure. Ordinary generic type parameters are not retained in the runtime type system as fully parameterized types.

Go's generics implementation differs from Java's type erasure mechanism: the Go compiler generates corresponding machine-code implementations based on the type parameters, and uses mechanisms such as dictionaries to handle some type operations. The specific implementation details are determined by the Go compiler.

3. Comparison of Generics Mechanisms

Comparison Dimension Go Java
Introduced in Go 1.18 Java 5
Type parameters Supported Supported
Type constraints Interface type sets Type bounds
Type erasure Does not use a Java-style generic erasure model Uses type erasure
Generic methods Supported Supported
Generic types Supported Supported
Wildcards No Java-style wildcards Supports ? extends, ? super
Type parameter constraints Supports union type sets, etc. Mainly expressed through bounds and wildcards

6. Differences in Concurrent Programming

The concurrency model is one of the most important differences between Go and Java.

Go treats lightweight concurrency as an important part of its language and runtime design; Java, by contrast, has built a complete system of threads and concurrency tools.

1. Go: Goroutines

A Goroutine is a lightweight unit of execution managed by the Go runtime.

A Goroutine can be started with the go keyword:

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from Goroutine")
}

func main() {
    go sayHello()

    time.Sleep(time.Second)
}

Here:

go sayHello()

starts a new Goroutine that executes the function concurrently.

Characteristics of Goroutines:

  • The cost of creation and switching is usually low.
  • The initial stack is small and can grow dynamically.
  • Scheduled by the Go Runtime.
  • Can be scheduled to run across multiple operating system threads.
  • Suitable for a large number of concurrent tasks.

Go's scheduler typically uses the G-M-P model:

  • G: Goroutine, representing a task to be executed.
  • M: Machine, representing an operating system thread.
  • P: Processor, representing the scheduling resource needed to execute Go code.

How G, M, and P work together:

flowchart TD
    A["Goroutine G"] --> B["Local run queue"]
    C["Global run queue"] --> B
    B --> D["Logical processor P"]
    D --> E["OS thread M"]
    E --> F["CPU execution"]
    F --> G{"Blocked or scheduled?"}
    G -->|"Continue execution"| F
    G -->|"Needs scheduling"| B

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

This model is a conceptual representation of the scheduling mechanism; it does not mean that each Goroutine is permanently bound to a thread.

2. Go: Channel

Go provides channels as a mechanism for communication and synchronization between Goroutines.

package main

import "fmt"

func worker(ch chan string) {
    ch <- "task completed"
}

func main() {
    ch := make(chan string)

    go worker(ch)

    result := <-ch

    fmt.Println(result)
}

Channels can be used for:

  • Passing data between Goroutines.
  • Task completion notifications.
  • Synchronization among multiple concurrent tasks.
  • Producer-consumer collaboration.

Go encourages sharing data through communication rather than relying solely on shared memory and locks.

However, channels do not mean that all shared state can be accessed without locks. When multiple Goroutines access shared data at the same time, a correct synchronization strategy is still required.

3. Java: Thread

Java traditionally uses Thread to represent an abstraction of an operating system thread.

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Hello from Thread");
        });

        thread.start();
    }
}

Calling start() starts a new thread to execute the task, whereas calling run() directly is just an ordinary method call and does not automatically create a new thread.

4. Java: Thread Pool

Java provides a thread pool abstraction through ExecutorService.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor =
            Executors.newFixedThreadPool(4);

        executor.submit(() -> {
            System.out.println("Task running");
        });

        executor.shutdown();
    }
}

A thread pool can reuse threads, reduce the overhead of frequently creating and destroying threads, and centrally manage task execution.

5. Java: Virtual Threads

Starting with Java 21, virtual threads became a standard feature.

Virtual threads are lightweight threads managed by the JVM and can support the concurrent execution of a large number of blocking tasks.

public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = Thread.ofVirtual().start(() -> {
            System.out.println("Hello from Virtual Thread");
        });

        thread.join();
    }
}

Both virtual threads and Go's Goroutines aim to reduce the resource overhead of highly concurrent tasks, but their scheduling mechanisms, runtime implementations, and ecosystem designs are different.

6. Concurrency Model Comparison

Comparison Dimension Go Java
Main Concurrency Unit Goroutine Thread, Virtual Thread
Scheduler Go Runtime JVM and operating system collaboration
Lightweight Concurrency Goroutine Virtual threads
Communication Mechanism Channel BlockingQueue, message queues, etc.
Synchronization Mechanism Mutex, RWMutex, Channel synchronized, Lock, Atomic
Thread Pool Goroutine pools or task scheduling schemes can be used, but it is usually unnecessary to create a thread pool for each Goroutine ExecutorService, etc.
Concurrency Model CSP-style communication model is common Thread and shared-memory model is mature
High-Concurrency I/O Goroutines with the network runtime Virtual threads, asynchronous APIs, thread pools, etc.

7. Concurrency Is Not the Same as Parallelism

Both Go and Java support concurrency, but concurrency and parallelism are different concepts.

  • Concurrency: Multiple tasks make progress alternately over time.
  • Parallelism: Multiple tasks execute at the same moment using different computing resources.

Neither Go's Goroutines nor Java's threads or virtual threads guarantee that tasks will execute in parallel.

The actual degree of parallelism depends on the number of CPU cores, the runtime scheduling policy, task type, and resource configuration.

VII. Differences Between Memory Management and Garbage Collection

Both Go and Java support automatic garbage collection, but their runtime structures and memory management strategies differ.

1. Go: Go Runtime Garbage Collection

Go uses a concurrent mark-sweep garbage collector and combines it with mechanisms such as write barriers to maintain object reachability information.

Its core goal is to reduce the impact of garbage collection pauses on application execution.

Go's memory management involves:

  • Heap memory allocation.
  • Stack memory management.
  • Object reachability analysis.
  • Concurrent marking.
  • Mark termination phase.
  • Memory sweeping and reclamation.
  • Memory statistics and tuning.

Go's garbage collection mainly targets objects allocated on the heap. The compiler may use escape analysis to determine whether certain objects can be allocated on the stack.

Example:

package main

type User struct {
    Name string
}

func createUser() *User {
    user := User{Name: "Alice"}
    return &user
}

Whether user is allocated on the heap is determined by the compiler based on escape analysis and the specific implementation; one cannot assert that all similar objects must be allocated in some fixed way simply because a function returns a pointer.

2. Java: JVM Garbage Collection

Java objects are usually managed by the JVM on the heap.

The JVM provides multiple garbage collectors to accommodate the latency, throughput, and memory requirements of different applications.

Common garbage collectors include:

  • Serial GC: single-threaded garbage collector.
  • Parallel GC: parallel garbage collector emphasizing throughput.
  • G1 GC: region-based garbage collector for larger heap memory.
  • ZGC: emphasizes low pause times.
  • Shenandoah GC: also emphasizes low-pause collection.

Different garbage collectors differ in concurrency capability, pause time, and memory overhead.

3. Comparison of Memory Management Processes

Conceptual garbage collection process in Go:

flowchart TD
    A["Object allocation"] --> B["Object enters heap memory"]
    B --> C["Identify GC cycle"]
    C --> D["Concurrent marking"]
    D --> E["Mark termination"]
    E --> F["Sweep unreachable objects"]
    F --> G["Release or reuse memory"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

Java's garbage collection process depends on the specific GC implementation; below is a conceptual reachability analysis process:

flowchart TD
    A["Object Allocation"] --> B["JVM Heap Memory"]
    B --> C["Identify GC Trigger Conditions"]
    C --> D["Analyze Reachability from GC Roots"]
    D --> E{"Is the Object Reachable?"}
    E -->|"Yes"| F["Retain Object"]
    E -->|"No"| G["Reclaim Object"]
    F --> H["Continue Running"]
    G --> H

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

Note that modern JVM garbage collectors may adopt different mechanisms such as generational collection, concurrent marking, concurrent compaction, and region-based collection. The figure above does not represent the complete execution steps of all Java GCs.

4. Memory Management Comparison

Comparison Dimension Go Java
Memory Management Automatic memory management JVM automatic memory management
Garbage Collector Go Runtime GC Multiple JVM GCs
Object Allocation Stack and heap, affected by escape analysis Objects are mainly managed by the JVM heap
Memory Tuning GOGC, GOMEMLIMIT, etc. Heap size, GC parameters, etc.
Collection Strategy Concurrent mark-sweep Depends on the GC type
Runtime Dependency Go Runtime JVM
Common Issues Memory escape, heap growth, GC overhead Heap memory overflow, object retention, GC pauses

Both languages require attention to memory allocation and object lifecycle. Garbage collection does not mean developers can ignore memory management.

VIII. Differences Between Compilation and Runtime Mechanisms

Go and Java differ significantly in terms of compilation output and runtime architecture.

1. Go: Compiled to Native Machine Code

Go typically uses go build to compile source code into a native executable for the target platform.

go build -o app main.go

Typical workflow:

flowchart TD
    A["Go Source Code"] --> B["Lexical and Syntax Analysis"]
    B --> C["Type Checking"]
    C --> D["Intermediate Representation"]
    D --> E["Machine Code Generation"]
    E --> F["Linking"]
    F --> G["Native Executable"]
    G --> H["Operating System Loads and Executes"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

The Go compiler compiles the code into machine code for the target platform and links the required runtime and dependencies.

Go programs can usually run in environments where the Go toolchain is not separately installed, but whether additional dynamic libraries are needed depends on the build method, operating system, and dependencies.

2. Java: Compiled to Bytecode

Java typically uses javac to compile source code into JVM bytecode.

javac Main.java
java Main

Compilation produces a .class file.

Java execution process:

flowchart TD
    A["Java source code"] --> B["javac compiler"]
    B --> C["JVM bytecode"]
    C --> D["Class loader"]
    D --> E["Bytecode verification"]
    E --> F["Interpreted execution or JIT compilation"]
    F --> G["Machine code execution"]
    G --> H["Program running"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px