Should I mark local variables and fields as final wherever possible?

Yes. Immutability is a cornerstone of modern Java. Marking variables final prevents accidental reassignment, helps the JIT compiler optimise code, and reduces bugs in multithreaded environments.

Java Types, Variables, and Memory Management

Q: What is the var keyword introduced in Java 10?

var enables local variable type inference. The compiler still knows the exact type at compile time so Java remains statically typed. It reduces boilerplate for verbose generic type declarations without sacrificing type safety.

← Back to Java Enterprise Mastery

Java Types, Variables, and Memory Management

1. Primitives vs. Objects: The Great Divide

Java maintains a "Dual-World" system:

Primitives (int, long, boolean, char): These store the Actual Value. They are tiny, allocated on the Stack, and are extremely fast for the CPU to process.
Objects (Integer, String, User): These store a Reference (a memory address) to data living on the Heap.

The Cost of "Wrapping":

Using Integer instead of int (Autoboxing) consumes significantly more memory. An int takes 4 bytes. An Integer object takes ~16-24 bytes due to the "Object Header" (metadata for the GC). In a list of a million numbers, this difference is the difference between an app that is fast and one that crashes with an OutOfMemoryError.

2. Memory Anatomy: Stack vs. Heap

Stack: Fast, temporary memory. Each thread has its own stack. When a method finishes, its stack memory is instantly wiped.
Heap: Large, shared memory. This is where all objects live. These stayed until the Garbage Collector decides they are no longer in use.

3. Pass-by-Value (The Common Myth)

Java is ALWAYS Pass-by-Value.

If you pass an int, you pass a copy of the number.
If you pass an Object, you pass a copy of the Reference (the remote control), not a copy of the actual object. This is why you can modify the contents of an object inside a method, but you cannot change which object the original variable points to.

4. Project Valhalla: Value Types

In 2026, Java is introducing Value Types (value class). The goal is to provide "Codes like a class, works like an int." This allows you to create complex objects (like a Point or a Money class) that are stored flat in memory like primitives, eliminating the "Reference Overhead" and making Java arrays as fast as C++ arrays.

Frequently Asked Questions

What is the 'var' keyword? Introduced in Java 10, var is Type Inference. It doesn't make Java dynamic; the compiler still knows exactly what the type is. It just saves you from typing HashMap<String, List<User>> twice. Use it for readability, but avoid it if it makes the code confusing.

Should I use 'final' for everything? Yes. In modern Java, Immutability is King. Marking variables as final helps the JIT compiler optimize code and prevents accidental bugs in multi-threaded environments.

Key Takeaway

Understanding Java's memory layout is what separates a student from a professional. By mastering the Stack vs. Heap divide and the nuances of primitive overhead, you gain the ability to build enterprise systems that are memory-efficient, lightning-fast, and ready for the next decade of JVM evolution.

Part of the Java Enterprise Mastery - engineering with precision.