Java Data Types: Primitives, Reference Types, and Defaults

Two Families: Primitives and References

Every value in Java has a type, and that type falls into one of two families. Primitive types hold a raw value directly - a number, a single character, or a true/false. Reference types hold a reference (a pointer) to an object living elsewhere in memory: String, arrays, and every class you or the libraries define.

The distinction matters because primitives are lightweight and copied by value, while reference variables point at shared objects. Start with the eight primitives - they are the foundation everything else is built on.

The Eight Primitive Types

Java has exactly eight built-in primitive types. Six are numbers, one is a character, one is a boolean:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // 8-bit integer,  -128 .. 127
        short  s = 30000;        // 16-bit integer
        int    i = 2_000_000;    // 32-bit integer (the default for whole numbers)
        long   big = 9_000_000_000L; // 64-bit integer - note the L

        float  f = 3.14f;        // 32-bit decimal - note the f
        double d = 3.141592653589793; // 64-bit decimal (the default for decimals)

        char   c = 'A';          // a single 16-bit Unicode character
        boolean flag = true;     // only true or false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

A few things to notice up front: the underscores in 2_000_000 are just visual separators the compiler ignores, the L and f suffixes are required (more on that below), and char uses single quotes while a String would use double quotes.

Choosing a Numeric Type

You almost never need byte or short - they save memory only in huge arrays. The real decisions are between int/long for whole numbers and float/double for decimals.

Type	Size	Use when
int	32-bit	The default for whole numbers (up to ~2.1 billion)
long	64-bit	Values past ~2 billion: millisecond timestamps, file sizes
double	64-bit	The default for decimals - good precision
float	32-bit	Only when memory is tight and precision can suffer

The trap is overflow. An int wraps around silently when it exceeds its range - no error, just a wrong answer:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // wraps to a negative number!

        long safe = (long) maxInt + 1;  // promote to long first
        System.out.println(safe);
    }
}

maxInt + 1 overflows to -2147483648 because both operands are int and the result stays an int. Casting one side to long first does the math in 64 bits. When a value might be large - especially milliseconds since 1970 - reach for long.

Literals and Their Suffixes

A bare number literal has a default type, and that bites people. 100 is an int; 3.14 is a double. To write a long or a float literal you must add a suffix:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // without L this is too big for int -> error
        float ratio = 0.5f;               // without f the right side is a double -> error
        double pi = 3.14;                 // fine - decimals default to double

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Drop the L from 8_000_000_000L and the code will not compile, because the literal exceeds the int range before it ever reaches the long variable. Drop the f from 0.5f and Java complains that a double cannot be assigned to a float without a cast. The suffix is case-insensitive, but use uppercase L - a lowercase l looks exactly like the digit 1.

char Is a Number in Disguise

A char stores a 16-bit Unicode code unit, which means it doubles as a small unsigned integer. You can do arithmetic on it and convert back and forth with a cast:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - the Unicode value of 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

This is occasionally handy for shifting letters, but do not lean on it for text - that is what String is for. Note char uses single quotes ('A'); double quotes ("A") make a one-character String, which is a completely different type.

Default Values (and the Local-Variable Gotcha)

Fields and array elements that you do not initialize get a sensible default. But this only applies to fields and array slots - local variables get no default, and using one before assigning a value is a compile error, not a runtime surprise.

public class Main {
    static int counter;        // field -> defaults to 0
    static boolean ready;      // field -> defaults to false
    static String name;        // field -> defaults to null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // array elements default to 0
        System.out.println(nums[0]); // 0
    }
}

If you instead wrote int x; System.out.println(x); inside main, the compiler would reject it with "variable x might not have been initialized." That strictness is a feature - it stops you from reading garbage. The defaults to remember: numeric types 0, boolean false, char '�', and every reference type null.

Next: Strings

String is the reference type you will touch most - text, joined values, user input. It behaves differently from the primitives here: it is an object, it is immutable, and comparing strings has its own pitfalls. The next page covers it.