.JAVA File Format – Types, values and variables

Integer arithmetic

• Arithmetic on byte, short and char operands is done in int (see numeric promotion): byte b = 1; b = b + 1; is an error, while b += 1; and b++ are allowed.
• Overflow wraps around silently: Integer.MAX_VALUE + 1 is Integer.MIN_VALUE. The Math.addExact family throws instead.
• Integer division rounds towards zero: -7 / 2 is −3. The remainder takes the sign of the dividend: -7 % 2 is −1.
• Integer division or remainder by zero throws ArithmeticException. The only other integer operator that can throw is unboxing a null wrapper, which throws NullPointerException.
• Integer.MIN_VALUE / -1 overflows to Integer.MIN_VALUE and does not throw.

Floating-point arithmetic

• float and double follow IEEE 754, with round to nearest. Since Java 17 every floating-point expression is evaluated exactly in its type on every platform (JEP 306). Before, intermediate results outside the strictfp modifier could use a wider exponent range.
• The values include positive and negative zero, positive and negative infinity and NaN (not a number). 1.0 / 0 is Infinity, 0.0 / 0 is NaN, and no floating-point operation throws.
• Every comparison with NaN is false, including NaN == NaN; only != is true. Test with Double.isNaN.
• 0.0 == -0.0 is true, but 1 / -0.0 is -Infinity. Double.equals and Double.compare treat the two zeros as different and NaN as equal to itself.
• The remainder % works on floating-point values, truncating like integer division: 5.5 % 2 is 1.5.

boolean and char

boolean is not a numeric type: there is no conversion between it and any other primitive type, and if (1) is an error. char is a 16-bit unsigned integral type holding one UTF-16 code unit. It takes part in arithmetic, so 'a' + 1 is the int 98 and (char) ('a' + 1) is 'b'.

Subtyping among primitive types

For primitive types the subtype relation is the direction of widening (JLS 4.10.1): double > float > long > int > char, and int > short > byte. boolean is unrelated to all of them.

final variables

A final variable can be assigned only once. A final field must be assigned by the end of every constructor (instance fields) or of class initialisation (static fields); a final variable declared without an initialiser is a blank final. Assigning it twice, or reading it before it is assigned, is a compile-time error (see Definite assignment). A final reference cannot be pointed elsewhere, but the object it refers to can still change.

A constant variable is a final variable of primitive type or String initialised with a constant expression. Its value is copied into every class that uses it at compile time, and it can be used in case labels.

static final int MAX = 100;            // constant variable
static final String NAME = "app";      // constant variable
static final long START = System.nanoTime();  // final, not constant
final List<String> names = new ArrayList<>();  // the list can still change
names.add("Ada");                      // allowed
// names = List.of();                  // error: names is final

Effectively final

A local variable or parameter that is not declared final is effectively final if it is never assigned after its initialisation (or, for a variable declared without an initialiser, is definitely unassigned before each assignment) and is never the operand of ++ or -- (JLS 4.12.4). Lambda bodies, inner classes, guards and try-with-resources (Java 9) can only use local variables from the enclosing code that are final or effectively final.

int count = 0;
String prefix = "n=";
Runnable r = () -> System.out.println(prefix);   // fine: prefix is effectively final
// Runnable s = () -> System.out.println(count); // error if count is changed below
count++;

Local variable type inference: var

var (Java 10, JEP 286) declares a local variable whose type is inferred from its initialiser. It is a reserved type name, not a keyword: it can still name a variable or method, but not a class or interface.

The inferred type is the type of the initialiser, after capture conversion and with wildcards replaced by their bounds. It can be a type that cannot be written in source, such as an anonymous class or an intersection type, which lets the variable use members of an anonymous class:

var point = new Object() { int x = 1, y = 2; };
System.out.println(point.x + point.y);   // 3: the type is the anonymous class

var items = new ArrayList<>();           // ArrayList<Object>: diamond with no other hint
var n = 10;                              // int
var big = 10L;                           // long

In lambda parameters (Java 11, JEP 323), var allows annotations on implicitly typed parameters: (@NonNull var x) -> x.length(). Either all parameters use var or none do.