Constants, final and Literals

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Literal

A value written directly in source code, like 42, 'x', true or "hello".

final

A modifier meaning 'can be assigned only once'. A final variable can't be changed after it gets its value.

Constant

A named value that never changes, usually a static final field such as MAX_SIZE.

Magic number

A bare number in code with no name explaining what it means, like 0.18 or 86400.

Blank final

A final variable declared without a value and assigned exactly once later.

Hexadecimal

Base 16, written with 0x. Digits are 0–9 then A–F, so 0xFF is 255.

Octal

Base 8, written in Java with a leading 0. 010 means eight.

Binary

Base 2, written with 0b, using only the digits 0 and 1. 0b101 is 5.

Compile-time constant

A final primitive or String whose value the compiler can work out from literals alone, so it can paste the value straight into the code.

1. 1

   Replace the magic numbers

   Write a program that prints the price of 3 items at 250 each with 18% tax and a 40 delivery fee, first with bare numbers. Then introduce static final constants ITEM_PRICE, GST_RATE and DELIVERY_FEE and check that the output is the same. Which version would you rather change next year?

2. 2

   Decode the literals

   Predict, then print: 0x10, 010, 0b10, 10L, 1e1, '1' + 1. Expected: 16, 8, 2, 10, 10.0, 50 (the code of '1' is 49).

3. 3

   See the constant in the bytecode

   Compile the last example and run javap -c -constants Main. Look for 86400: the field holds the folded number, and in main the compiler went further and joined the whole message into one constant String. There is no multiplication and no field read left.

   terminalcopy cmd

   $ javac Main.java

   javap -c -constants Main | grep 86400

   ── expected output ──

   static final int SECONDS_PER_DAY = 86400;

   3: ldc #15 // String seconds per day: 86400

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

public class Main {
    static final int MAX_PLAYERS = 4;

    public static void main(String[] args) {
        MAX_PLAYERS = 5;
        System.out.println(MAX_PLAYERS);
    }
}

public class Main {
    public static void main(String[] args) {
        final int total;
        total = 10;
        total = 20;
    }
}

public class Main {
    public static void main(String[] args) {
        int pinCode = 0412;
        int day = 09;
        System.out.println(pinCode + " " + day);
    }
}

1. 1

   final on a variable means assign exactly once. final int lives = 3; can be read as often as you like, but lives = 4; is a compile error. A blank final is declared without a value and assigned later, exactly once on every path; the same definite-assignment rules from Topic 1.1 check it.

2. 2

   A constant is a static final field of a primitive type or String set to a fixed value: static final int MAX_PLAYERS = 4;. By convention its name is UPPER_SNAKE_CASE. Constants replace magic numbers: a bare 0.18 in a formula tells the reader nothing, GST_RATE tells them everything, and changing the rate later means editing one line. (static is explained in Topic 4.6; for now read it as 'belongs to the class, one copy'.)

3. 3

   Integer literals are int by default; add L for long (3_000_000_000L). Write them in four bases: decimal 255, hexadecimal 0xFF, binary 0b1111_1111 (Java 7) and octal with a leading zero, 0377. That last one is a trap: 010 is 8, not 10, and 09 doesn't compile. Underscores (Java 7) may separate digits for readability, 1_000_000, but not at the start or end of a number or next to the decimal point.

4. 4

   Floating-point literals are double by default: 2.5, .5, 5., and scientific 1e3 (1000.0) or 1.5e-3 (0.0015). Add f for float (2.5f); float f = 2.5; doesn't compile because a double can't be narrowed silently (Topic 1.4). The suffix d is allowed but redundant.

5. 5

   Other literals: char in single quotes ('A', '\n', '\u0041', Topic 1.5), boolean (true, false), String in double quotes (Topic 1.10) and text blocks in triple quotes (Java 15, Topic 6.5), and null, the literal for 'no object'. Note that true, false and null are literals, not keywords, but you still can't use them as names.

6. 6

   final freezes the variable, not the object. final int[] scores = {10, 20}; can't be pointed at another array, but scores[0] = 99; is allowed. For truly unchangeable data you need immutable objects (Topic 4.11). When a final primitive or String is initialised with a constant expression, the compiler treats it as a compile-time constant and pastes its value directly wherever it's used.

• ↔

  Marking every local final documents intent and prevents accidental reassignment, but adds noise; many teams use it for fields and important values and rely on 'effectively final' elsewhere.

• ↔

  public static final constants are fast and simple, but they are inlined into other classes; values that may change between releases are safer behind a method or in configuration.

• ↔

  A group of int constants is compact, but any int can be passed where one was expected; an enum gives type safety and names at a small memory cost.

• I can use final for locals, blank finals and static final constants, and fix the related compile errors.

• I name constants in UPPER_SNAKE_CASE and replace magic numbers with them.

• I can write and read integer literals in decimal, hex, octal and binary, with underscores and the L suffix.

• I know the leading-zero octal trap and store codes like PINs as Strings.

• I know the default types of number literals and when f, L are needed.

• I can explain that final freezes the variable, not the object, and what a compile-time constant is.