Data types

What it is and why it exists

A data type defines what a value can represent and which operations accept it. Java is statically typed: before code runs, the compiler checks whether assignments, method calls, and expressions can be combined under the language rules. A variable’s type does not change when it later holds a different value; var merely asks the compiler to infer one fixed local-variable type from the initializer.

Java divides types into primitive types and reference types . The eight primitive types are built-in value categories; classes, interfaces, arrays, and type variables are reference types. A primitive variable cannot hold null, while a reference variable holds a reference to an object or array, or the null reference.

You encounter this distinction at almost every API boundary. Arithmetic expressions apply numeric promotion, generic collections require wrapper types, database or deserialized data may produce null, and text processing must distinguish a char from a complete Unicode code point. Knowing the rules lets you ask whether a compiler-approved conversion also preserves the business meaning.

The eight primitive types

Java specifies the widths and ranges of its integral types, so those semantics do not change with the processor platform. A boolean has only the values true and false; the Java Language Specification does not prescribe its storage size in an object layout.

int is usually the default integer choice, and an integer literal also has type int by default. Integer literals outside that range normally need an L suffix to become long. Floating-point literals default to double; assigning one to float requires an F suffix or a cast. Suffixes select literal types, but they do not prevent runtime arithmetic from overflowing or rounding.

Reference types and objects

A reference value is not the object’s contents. Assigning an array, string, or ordinary object reference to another variable makes both variables point to the same object. If the object is mutable, a change through one reference is visible through the other. Java passes every argument by value; for a reference type, the copied value is the reference itself.

An array is an object even when its elements are primitives. An int[] has int elements, whereas an Integer[] has reference elements and each element may be null. Generic type arguments cannot be primitive types, so List<int> is illegal and a general-purpose integer collection uses List<Integer>.

Defaults belong only to certain storage locations

Instance fields, static fields, and elements of a newly created array receive default values. Numeric primitives default to zero, char to \u0000, boolean to false, and reference types to null. These defaults give objects and arrays a defined state immediately after construction.

Local variables have no default value. The compiler performs definite-assignment analysis, and reading a local that is not certainly assigned on that path is a compile-time error. This rule stops a method from treating uninitialized stack state as a valid business value.

Select types from a contract

A type choice starts with the permitted value set, not the smallest representation that fits today’s sample. Use int for ordinary bounded counts and long when the documented range requires it. If overflow is an error rather than modular arithmetic, the contract also needs validation or exact operations; choosing a wider type alone only moves the boundary.

Absence is a separate decision from numeric range. A primitive says every instance has a value, while a wrapper can encode absence with null but requires every consumer to handle that state. A sentinel such as -1 is safe only when the domain excludes it and the API documents its meaning.

Some data that looks numeric is not a quantity. Account numbers, postal codes, and externally assigned identifiers may need leading zeros, formatting, or more digits than arithmetic types provide. Represent them as text or a domain type unless arithmetic operations are part of their contract.

Use byte[] for encoded bytes and char or String for UTF-16 text, but do not convert between them by casting. Text-to-byte conversion requires an explicit character encoding such as UTF-8. That boundary belongs in an encoder or decoder API where malformed-input behavior can be chosen deliberately.

How it works

Declarations, assignments, and calls

A variable declaration establishes a static type, and an assignment expression must produce that type through an assignment conversion. Method invocation uses method-invocation conversions to determine which overloads apply. A cast unlocks additional conversions, but it only asks Java to change a representation or check a reference type according to fixed rules; it does not prove that the result fits the business range.

A reference assignment can widen, such as assigning an ArrayList<String> reference to a List<String> variable. A downcast is explicit and checks at runtime whether the object belongs to the target type; failure throws ClassCastException. Pattern matching for instanceof combines the test with a safe local binding.

Conversion phases in overloaded calls

Overload resolution considers conversions in phases. Fixed-arity candidates that need only identity, widening primitive, or widening reference conversions are considered before candidates that require boxing or unboxing. Variable-arity candidates are considered only after the fixed-arity phases fail.

This ordering means adding a wrapper overload can change which generated call is selected, even though each method would compile by itself. A primitive widening overload may win before a boxing overload, while an existing wrapper reference may widen to Object in an earlier phase than it could unbox for a primitive parameter. Read the declared argument type as well as its runtime value when checking a call.

The null literal can be passed to reference parameters but not primitive parameters. If unrelated reference overloads are equally specific, a call with bare null can become ambiguous at compile time. Avoid overload families whose only distinction is unrelated wrapper types; a domain-specific method name usually expresses the contract more clearly.

Widening and narrowing primitive conversions

A widening primitive conversion sends a value to a target type allowed by the language. byte, short, and char can widen to int, and integral types can continue through the allowed wider integral or floating-point types. Widening an integer to a wider integer preserves the value, but int to float, long to float, and long to double can lose precision because the target has too few significant bits.

A narrowing conversion requires an explicit cast except for a few constant-assignment rules. Narrowing an integer discards high bits and can change the sign. Converting floating point to an integer first rounds toward zero, then applies the specified results for NaN and out-of-range values. An ordinary numeric cast does not throw merely because the source is outside the target range.

The common widening paths are below. An arrow implied by the table means a widening conversion exists, not that every step preserves numeric precision.

boolean does not participate in numeric conversion. Java neither accepts 0 and 1 as Boolean values nor permits casts between Boolean and integral types. This keeps the intent of condition expressions explicit.

Numeric promotion and intermediate results

Unary and binary numeric operations perform numeric promotion . byte, short, and char are promoted to int for most arithmetic, so even the type of two added byte values is int. Mixed numeric operands use binary numeric promotion to select a common type.

A wider result variable cannot rescue an intermediate result that already overflowed. In long total = intPrice * intQuantity, multiplication finishes as int before the result is widened to long. Widening one operand before multiplication, or using Math.multiplyExact, changes the range of the multiplication itself or turns overflow into an exception.

Compound assignment also includes implicit narrowing. count += delta is roughly equivalent to count = (T) (count + delta), where T is the left-hand type, except that the left side is evaluated only once. A byte += expression can therefore compile and still wrap silently.

Boxing, unboxing, and null

Autoboxing converts a primitive value to the corresponding wrapper reference, such as int to Integer. Unboxing performs the reverse conversion. The compiler inserts these conversions when generic collections, assignments, calls, or expressions require them.

A wrapper object has reference identity, but most application code cares about the wrapped value. == on two Integer references compares identity unless the expression first triggers unboxing. The specification guarantees identity for some boxed small constants, which can make broken code appear correct with small test data. Use equals or Objects.equals to compare wrapper values.

Unboxing a null wrapper reference throws NullPointerException. The unboxing can be hidden inside arithmetic, a relational comparison, a conditional expression, a method argument, or an enhanced for loop. An API must state whether a missing value is allowed, then validate it, supply a domain-meaningful default, or preserve the reference form before unboxing.

Floating point, decimals, and text

float and double use binary floating-point representations. Many decimal fractions have no finite binary representation, so the result of 0.1 + 0.2 is not the same double as 0.3. These types suit measurements, scientific calculations, and values with an accepted error model, but they usually do not suit money that requires exact decimal values and a fixed rounding policy.

BigDecimal represents a decimal with an arbitrary-precision integer and a scale. Use the string constructor when the input is external decimal text; new BigDecimal(0.1) faithfully captures the already inexact double. Division may need an explicit precision or rounding mode. equals also compares scale, while compareTo compares numeric order.

A char represents one UTF-16 code unit, not necessarily one complete user-visible character. A Unicode code point outside the Basic Multilingual Plane uses a surrogate pair, so a string’s length() can differ from its code-point count. Use codePoints(), codePointAt, or code-point offset APIs when you need to traverse complete code points.

Arrays preserve runtime component types

An array object remembers its component type at runtime. Java arrays are covariant, so a String[] can be assigned to an Object[] variable, but the underlying object is still a string array. Storing a non-string through that broader reference compiles and then throws ArrayStoreException.

Generic collections make a different tradeoff. List<String> is not a subtype of List<Object>, so the analogous unsafe write is rejected at compile time. Generic type arguments are erased in ordinary Java generics, while an array’s component-type check remains reified at runtime.

Primitive arrays also avoid per-element boxing semantics. An int[] element always has an int value and begins at zero; an Integer[] element is a reference and begins at null. Pick between them from the API’s need for generic interoperability and missing values, then measure performance only if it matters.

Examples

Primitives and references

The literal suffixes give orderId and packageWeightKg the required types. The last line demonstrates that array variables hold references: changing the element through sameOrders makes the same change visible through dailyOrders.

Conversions and overflow checks

public class NumericConversions {
    public static void main(String[] args) {
        int exactInteger = 16_777_217;
        float roundedFloat = exactInteger; // Widens the type but loses one unit of precision.

        int shipmentCode = 130;
        byte narrowedCode = (byte) shipmentCode; // Keeps only the low eight bits.

        byte packedCount = 12;
        packedCount += 120; // Includes an implicit narrowing conversion.

        System.out.printf("int=%d float=%.0f%n", exactInteger, roundedFloat);
        System.out.println("narrowed=" + narrowedCode + ", compound=" + packedCount);

        try {
            Math.toIntExact(3_000_000_000L);
        } catch (ArithmeticException error) {
            System.out.println("overflow detected");
        }
    }
}

int=16777217 float=16777216
narrowed=-126, compound=-124
overflow detected

The first line shows that widening does not imply exact conversion. The two byte results come from retaining low bits rather than throwing. Math.toIntExact fits a boundary that must reject an out-of-range value.

Wrappers and missing values

import java.util.List;
import java.util.Objects;

public class BoxingValues {
    public static void main(String[] args) {
        List<Integer> quantities = List.of(2, 3, 4); // Adding elements requires boxing.

        int total = 0;
        for (int quantity : quantities) { // Reading each element requires unboxing.
            total = Math.addExact(total, quantity);
        }

        Integer expected = 9;
        Integer actual = Integer.valueOf(total);
        Integer missing = null;

        System.out.println("total=" + total);
        System.out.println("matches=" + Objects.equals(expected, actual));
        System.out.println("fallback=" + Objects.requireNonNullElse(missing, 0));
    }
}

total=9
matches=true
fallback=0

The collection’s element type must be Integer, while the accumulator can remain an int. Objects.equals handles value comparison and null references. A default is appropriate only when the domain genuinely interprets absence as zero.

Exact decimals and Unicode code points

import java.math.BigDecimal;
import java.math.RoundingMode;

public class DecimalAndText {
    public static void main(String[] args) {
        BigDecimal unitPrice = new BigDecimal("19.95");
        BigDecimal quantity = BigDecimal.valueOf(3);
        BigDecimal taxRate = new BigDecimal("0.075");

        BigDecimal subtotal = unitPrice.multiply(quantity);
        BigDecimal tax = subtotal.multiply(taxRate)
                .setScale(2, RoundingMode.HALF_UP);

        BigDecimal oneDecimal = new BigDecimal("1.0");
        BigDecimal twoDecimals = new BigDecimal("1.00");
        String vehicle = "🚗";

        System.out.println("subtotal=" + subtotal + ", tax=" + tax);
        System.out.println("numericEqual=" + (oneDecimal.compareTo(twoDecimals) == 0));
        System.out.println("equals=" + oneDecimal.equals(twoDecimals));
        System.out.println("units=" + vehicle.length()
                + ", codePoints=" + vehicle.codePointCount(0, vehicle.length()));
    }
}

subtotal=59.85, tax=4.49
numericEqual=true
equals=false
units=2, codePoints=1

The money enters BigDecimal from decimal strings, and the rounding rule appears only at the boundary where tax needs two fractional digits. The other lines expose BigDecimal’s scale semantics and the difference between UTF-16 code-unit and Unicode code-point counts.

Pitfalls

Further reading

• Java Language Specification: types, values, and variables
• Java Language Specification: conversions and contexts
• Java Language Specification: expressions
• Java SE 25 API: BigDecimal