.JAVA File Format – Definite assignment

The two rules

Fields that are not blank finals, array components and parameters always have a value, so they are not checked. A read means any use of the variable’s name except as the left side of a simple = assignment.

int x;
if (flag) x = 1;
System.out.println(x);      // error: x might not have been initialized

int y;
if (flag) y = 1; else y = 2;
System.out.println(y);      // fine: assigned on both branches

final int z;
z = 1;
z = 2;                      // error: z might already have been assigned

Conditions and boolean operators

For boolean expressions the analysis tracks two states: what is assigned when the expression is true, and when it is false (JLS 16.1):

• a && b: a variable is DA when true if it is DA after a or after b when they are true; DA when false only if it is DA when a is false and when b is false.
• a || b: the mirror image.
• !a: swaps the two states.
• The constant true counts as assigning every variable “when false”, because that case cannot happen; false the same “when true”.

int n;
if (s != null && (n = s.length()) > 0) {
    use(n);                 // fine: n is assigned when the condition is true
}

int k;
while (true) {
    k = read();
    if (k >= 0) break;
}
use(k);                     // fine: the loop only ends through the break, after k = read()

Statements

Inside a catch block, a variable assigned in the try block is not DA, because the exception may have come first. A final variable assigned in a loop body is not DU on the next iteration, so it cannot be assigned there.

Switch expressions and yield

A variable is DA after a switch expression if it is DA before every yield and at the end of every expression rule; for a boolean switch expression, the analysis tracks the true and false states of each result, as for ? :.

final String kind;
switch (code) {
    case 1 -> kind = "one";
    case 2 -> kind = "two";
    default -> throw new IllegalArgumentException();
}
use(kind);                  // fine: every path assigns kind exactly once

Blank final fields

• A blank final static field must be DA at the end of the static initialisers and static field initialisers, in textual order, and DU before its one assignment.
• A blank final instance field must be DA at the end of every constructor that does not start with this(…), taking the instance initialisers into account. A constructor that calls this(…) must not assign it, since the other constructor already does.
• Inside the constructors and initialisers, a blank final field may be read, by its simple name or as this.x, only once it is DA. Reading it from a method that the constructor calls is not checked, and can see the default value.
• A lambda body in a constructor or initialiser may read a blank final field only if it is DA before the lambda expression.

class Temperature {
    private final double kelvin;

    Temperature(double celsius) {
        if (celsius < -273.15) throw new IllegalArgumentException();
        kelvin = celsius + 273.15;      // assigned exactly once on every normal path
    }

    Temperature() { this(20); }        // must not assign kelvin
}

Lambdas, inner classes and effectively final

A local variable used in a lambda body, a local or anonymous class, or a switch guard must be DA before that body, and must be final or effectively final. A variable declared without an initialiser can still be effectively final if it is DU before each assignment:

String msg;
if (ok) msg = "done"; else msg = "failed";   // assigned once on each path
Runnable r = () -> System.out.println(msg);   // fine: msg is effectively final