Default values, literals and constants

For this lesson, we'll focus on the rules that decide when Java fills in a value for you, every literal form you'll meet in real code, and how final and static final constants behave, including one constant-inlining pitfall that has broken real deployments. Interviewers use this topic to test precision: "what's the default value of a local int?" has a wrong answer that sounds right.

01Picture it first: who gets a default?

Think of the JVM as a landlord. When it hands you a new object or array, it cleans the room first: the memory is zeroed, so every field and element reads as 0, false or null. A local variable is different: it's a scratch slot in a stack frame that's reused from call to call, and the compiler, not the JVM, makes sure you never read it before writing it.

Fig. 1

Fields and array elements are zeroed by the JVM and get default values; local variables get no default and must be definitely assigned before use

02Fields vs locals: definite assignment

class Counter {
    int hits;                 // field
    Integer boxedHits;        // field, reference type
    boolean enabled;          // field

    void report() {
        int local;
        System.out.println(hits + " " + boxedHits + " " + enabled);
        int[] buckets = new int[3];
        System.out.println(buckets[0]);
        System.out.println(local);   // ?
    }
}

The last line doesn't compile: variable local might not have been initialized. Remove it and you get 0 null false, then 0.

Notice three things:

1. hits is 0, but boxedHits is null, not 0. A wrapper field is a reference, and unboxing it (boxedHits + 1) throws NullPointerException.
2. The array elements are zeroed even though buckets is a local. The array object lives on the heap and gets cleaned; only the local reference needs assigning.
3. The local int has no value at all. This isn't a runtime check: javac runs a flow analysis called definite assignment (JLS chapter 16) and refuses any path where a read could happen before a write.

Definite assignment is smarter than "assigned on the line it's declared":

int status;
if (ok) {
    status = 200;
} else {
    status = 500;
}
System.out.println(status);   // fine: assigned on every path

int retries;
if (ok) retries = 3;
System.out.println(retries);  // compile error: not assigned when !ok

03Literals: every form you'll meet

int million   = 1_000_000;          // underscores (Java 7) are ignored
int mask      = 0xFF;               // hex: 255
int flags     = 0b1010_0001;        // binary (Java 7): 161
int perms     = 0755;               // octal! 493, not 755
long big      = 9_000_000_000L;     // needs L: too big for int
float ratio   = 0.75f;              // needs f: 0.75 alone is a double
double d      = 1e-3;               // 0.001, the D suffix is optional
char letter   = 'A';                // also '\u0041' or (char) 65
char tab      = '\t';               // escapes: \t \n \r \b \f \s \' \" \\ and \0..\377 octal

A few rules hide in there:

• Integer literals are int unless they end in L. long big = 9000000000; doesn't compile: integer number too large. Use a capital L; a lowercase l looks like 1.
• Decimal literals with a point or exponent are double. float f = 1.5; is a compile error, because double → float is narrowing. Add f.
• A leading 0 means octal. 010 is 8 and 08 doesn't compile. This catches people formatting codes like 0755 or zero-padded IDs.
• Underscores must sit between digits: 1_000 is fine, _1000, 1000_ and 0x_FF aren't.
• \s (a single space) was added with text blocks in Java 15.

Text blocks (Java 15)

A text block is a multi-line String literal between triple quotes. Java removes the common leading indentation (measured from the least-indented line, including the closing """), normalises line endings to \n, and keeps the rest exactly as written.

String json = """
    {
      "name": "atlas",
      "tags": ["java"]
    }
    """;

That gives you the JSON with the four-space margin stripped and a trailing newline (because the closing """ is on its own line). End a line with \ to join it with the next one, and use \s to keep trailing spaces that would otherwise be stripped. A text block is still a plain String constant, so it's interned and can be a compile-time constant like any other literal.

04final and static final

final means assigned exactly once. It applies to three things:

final freezes the variable, not the object it points to. final List<String> names = new ArrayList<>(); can't be pointed at another list, but names.add("x") works fine. For a read-only collection, use List.of(...) or Collections.unmodifiableList(...).

public final class HttpLimits {
    public static final int MAX_RETRIES = 3;               // compile-time constant
    public static final String USER_AGENT = "atlas/1.0";   // compile-time constant
    public static final long TIMEOUT_MS = 30 * 1_000L;     // still constant: constant expression
    public static final Integer BOXED = 3;                 // NOT a compile-time constant (wrapper)
    public static final int FROM_ENV = Integer.getInteger("retries", 3); // NOT constant: runtime call
    public static final List<String> HOSTS = List.of("a", "b");         // NOT constant: object

    private HttpLimits() {}
}

Naming convention: constants are UPPER_SNAKE_CASE, and in practice that means static final fields whose value is deeply immutable (primitives, String, immutable collections). A static final StringBuilder is not a constant in spirit, so name it like a normal field. Ordinary final locals and fields keep camelCase.

05The constant-inlining pitfall

A compile-time constant (JLS §4.12.4) is a final variable of primitive type or String, initialised with a constant expression. For these, javac doesn't emit a field read in the classes that use them. It copies the value into their bytecode.

It still prints 3. Run javap -c Client and you'll see iconst_3, not getstatic HttpLimits.MAX_RETRIES: the number was baked in when Client was compiled. In a quick test, BOXED and FROM_ENV do pick up the new value, because they're real field reads.

There's one more side effect: reading a compile-time constant from another class doesn't trigger that class's static initialisation, because no getstatic instruction runs. Reading BOXED does.

06How to say it in the interview

When I ask about defaults, I'm listening for whether you separate fields and arrays from locals without hesitating, and whether you know the local rule is enforced by the compiler. On constants, I'm listening for the word "inlined" and the deployment risk that comes with it.

Here's how this might look if you sketch it on the whiteboard: