Data Types

Local variables don't get default values. The compiler requires you to assign a value before reading one, so it rejects the code with 'variable x might not have been initialized'. A field would instead default to 0.

A literal is a fixed value written directly in source code, like 42, 3.14, 'A', "hello", true, or null. Java has integer, floating-point, character, string, boolean, and the null literal.

Java does not throw an error. The value silently wraps around: adding 1 to the largest int gives the smallest (most negative) int. No warning, no exception.

Uninitialized primitive fields get defaults: 0 for numbers, 0.0 for float/double, '' for char, false for boolean. Local variables get NO default — you must assign before use or the code won't compile.

Java has eight primitives: byte (8 bits), short (16), int (32), long (64), float (32), double (64), char (16), and boolean. They hold simple values directly, not objects.

NaN means 'Not a Number' and comes from undefined operations like 0.0/0.0. It is never equal to anything, even itself, so NaN == NaN is false. Use Double.isNaN(x) to check for it.

L makes an integer literal a long, f makes a number a float, and d makes it a double. Without L, big literals stay int and can overflow during arithmetic; adding L forces 64-bit math.

float and double store numbers in binary (base 2), and many decimals like 0.1 can't be represented exactly, so tiny rounding errors creep in. For money, use BigDecimal or integer cents, not double.

Doubles store numbers in binary, and 0.1, 0.2, 0.3 can't be represented exactly, so tiny rounding errors creep in: 0.1 + 0.2 is 0.30000000000000004. Never compare with == — compare within a tolerance, or use BigDecimal for money.

char is a 16-bit unsigned number holding one UTF-16 character code (0 to 65535). It is the only unsigned primitive, and you can do arithmetic on it because it is numeric under the hood.

Creating an array fills every slot with the type's default: new int[3] gives {0,0,0} and new String[3] gives {null,null,null}. The array object's memory is zeroed when allocated, so the elements are already safe to read.

Hex uses prefix 0x (0x1F), binary uses 0b (0b1010), octal uses a leading zero (017). The trap: a leading zero makes the number octal, so 010 is 8, not 10.

A string literal is text in double quotes; identical literals are shared (interned) in a string pool, so "hi" == "hi" is true. Underscores group digits in numbers for readability, like 1_000_000, but can't sit at the start, end, or next to a dot or base prefix.

Floating-point doesn't wrap. Too-big results become Infinity (or -Infinity); too-small results lose precision and shrink toward 0.0. Neither throws an exception. Integer overflow instead wraps around silently.

They do the same math as + and *, but throw an ArithmeticException if the result overflows instead of silently wrapping. Use them where a wrong number would be dangerous.

The value silently wraps around: adding 1 to the maximum int (2147483647) gives the minimum int (-2147483648). Java does not throw an error. Use a long, or Math.addExact to throw on overflow.

Widening (small to big, like int to long) happens automatically because no data is lost. Narrowing (big to small, like long to int) can lose data, so Java forces you to write an explicit cast.

Dividing a non-zero number by zero gives infinity (Double.POSITIVE_INFINITY or NEGATIVE_INFINITY) instead of throwing. Infinity arithmetic mostly stays infinite, but undefined combos like Infinity - Infinity give NaN.

A final field is briefly default-initialized (0/false/null) like any field, but the compiler still forces you to assign it exactly once before the constructor finishes. So you can't rely on the default as its final value.

A char literal is one character in single quotes, like 'A'. Escapes like '\n' or '\t' write special characters. 'A' is a Unicode escape for 'A'. The surprise: \uXXXX is processed very early, before the code is even tokenized.

Floating-point literals have a decimal point or an exponent: 3.14, 1.5e3 (means 1500), .5, 2f. Without a suffix they are double (64-bit, more precise); with f they are float (32-bit, less precise). There is no literal for infinity or NaN — those come from constants.

For large arrays, low + high can exceed Integer.MAX_VALUE and overflow to a negative number, so mid becomes wrong (often negative). Fix it with low + (high - low) / 2, which never overflows.

Primitive ==/</> follow IEEE 754: NaN is never equal (even to itself) and -0.0 equals 0.0. Double.compare/Double.equals instead define a clean total order: NaN equals itself and sorts last, and -0.0 sorts below +0.0. For equals/hashCode and sorting, use Double.compare.

Floating-point has two zeros: +0.0 and -0.0. They compare equal with ==, but you can tell them apart with Double.compare or by checking 1.0/x (gives +Infinity for +0.0, -Infinity for -0.0).

Match the type to the value range and the cost of being wrong: int for small bounded counts, long for big counts/IDs/time, BigInteger/BigDecimal when values are unbounded or must be exact (money), and Math.*Exact at trust boundaries to fail loudly instead of wrapping.