Java Data Types Explained with Examples

Every value in a Java program has a type, and the compiler enforces those types before a single line runs. That strictness is Java's biggest gift to beginners: entire categories of bugs get caught at compile time instead of exploding in production. But it also means you cannot write serious Java until the type system is second nature.

This guide covers both families — primitives and reference types — plus the casting rules and overflow behavior that interviewers use to separate memorizers from people who actually understand the machine.

The two families: primitive vs reference

Java splits all types into two camps:

• Primitive types store the value itself, directly in the variable. There are exactly 8, they are built into the language, and their names are lowercase: int, double, boolean and friends.
• Reference types store a reference (an address) to an object living on the heap. String, arrays, ArrayList, and every class you write are reference types.

The practical differences show up everywhere:

That fourth row causes real bugs: == on two String objects compares references, not text. Why strings behave this way — and the string pool that complicates it — gets full treatment in Java strings.

The 8 primitive types at a glance

Two habits worth forming immediately: use int for whole numbers and double for decimals unless you have a measured reason not to. byte, short and float exist for specific niches; reaching for them "to save memory" in ordinary code is premature optimization.

Here is each family in action:

public class PrimitivesTour {
    public static void main(String[] args) {
        int seats = 30;                  // everyday whole number
        long worldPopulation = 8_100_000_000L;  // needs L suffix: too big for int
        double price = 1499.99;          // everyday decimal
        float rating = 4.5f;             // needs f suffix
        char grade = 'A';                // single quotes for char
        boolean enrolled = true;

        byte flags = 0b0101;             // binary literal
        short year = 2026;

        System.out.println(seats + " seats, price " + price
                + ", grade " + grade + ", enrolled: " + enrolled);
        System.out.println("Population: " + worldPopulation
                + ", rating: " + rating + ", flags: " + flags + ", year: " + year);
    }
}

Notice the suffixes: L makes a literal long, f makes it float. Without L, the literal 8_100_000_000 fails to compile because integer literals are int by default and that value exceeds the int range. The underscores in numeric literals are legal and purely for readability.

Pro tip: When a whole number might ever exceed 2.14 billion — database IDs, epoch milliseconds, view counts — start with long. Migrating a codebase from int to long after an overflow incident is painful; System.currentTimeMillis() returning long is the API's way of telling you this.

Integer overflow: the silent wraparound

Java does not throw an error when an int calculation exceeds its range. It silently wraps around, which produces spectacular bugs:

public class OverflowDemo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;         // 2,147,483,647
        System.out.println(max + 1);          // -2147483648 (wrapped!)

        // int tooBig = 3_000_000_000;       // compile error: exceeds int range
        long safe = 3_000_000_000L;           // correct: use long
        System.out.println("Safe value: " + safe);

        // classic interview bug: multiplying ints before widening
        long wrong = 2_000_000 * 2_000;       // overflows as int math first
        long right = 2_000_000L * 2_000;      // long math from the start
        System.out.println("wrong = " + wrong + ", right = " + right);
    }
}

The last pair is the one to internalize: 2_000_000 * 2_000 is computed in int arithmetic before being assigned to long, so the damage is already done. Making one operand long forces the whole multiplication into 64-bit math.

Interview note: "What happens when int overflows in Java?" The answer is silent wraparound (modulo 2^32), never an exception. Mention Math.addExact() and Math.multiplyExact(), which throw ArithmeticException on overflow, and you have turned a basic question into a strong answer.

Floating point: why 0.1 + 0.2 != 0.3

double stores numbers in binary, and many decimal fractions have no exact binary representation. Run this once and never forget it:

public class MoneyMistake {
    public static void main(String[] args) {
        System.out.println(0.1 + 0.2);            // 0.30000000000000004
        System.out.println(0.1 + 0.2 == 0.3);     // false

        // The right way for money: BigDecimal from Strings
        java.math.BigDecimal fee = new java.math.BigDecimal("999.10");
        java.math.BigDecimal gst = new java.math.BigDecimal("179.84");
        System.out.println(fee.add(gst));          // 1178.94 exactly
    }
}

double is fine for scientific calculations, percentages and averages where tiny imprecision is acceptable. For money, use BigDecimal constructed from a String (never from a double, which imports the imprecision you were escaping) or keep amounts in integer paise.

char and boolean: the odd ones out

char is a 16-bit unsigned type holding one UTF-16 code unit. It uses single quotes ('A'), and because it is numeric underneath, 'A' + 1 is 66. That numeric nature enables tricks like char next = (char) ('A' + 1); yielding 'B'.

boolean holds only true or false. Unlike C, Java refuses to treat numbers as booleans — if (1) is a compile error, which kills the classic if (x = 5) typo-bug at the source. Booleans drive the conditions you will write with Java operators in every if and loop.

Reference types and null

Every non-primitive is a reference type: String, arrays, collections, your own classes. Three consequences matter from day one:

1. They can be null — meaning "refers to nothing". Calling a method on a null reference throws NullPointerException, the most common exception in all of Java.
2. Assignment copies the reference, not the object. Two variables can point at the same object; changing it through one is visible through the other.
3. == compares references. Use .equals() to compare object contents.

Arrays deserve special mention: even an array of primitives like int[] is itself a reference type living on the heap. Their behavior gets a full guide in Java arrays.

Type casting: widening and narrowing

Java converts between numeric types in two directions:

Widening (implicit, safe): small type to large type happens automatically because no information can be lost. byte → short → int → long → float → double.

Narrowing (explicit, risky): large to small requires a cast operator and can lose data:

public class CastingDemo {
    public static void main(String[] args) {
        int rupees = 500;
        double amount = rupees;          // widening: automatic, 500.0

        double precise = 99.99;
        int truncated = (int) precise;   // narrowing: cast required
        System.out.println(truncated);   // 99 — decimal part DROPPED, not rounded

        int big = 130;
        byte b = (byte) big;             // 130 doesn't fit in byte
        System.out.println(b);           // -126 — wrapped around
    }
}

Two behaviors to notice: casting double to int truncates toward zero (99.99 becomes 99, not 100 — use Math.round() if you want rounding), and narrowing an out-of-range value wraps around silently, just like overflow.

Common mistake: A common mistake beginners make is assuming (int) 99.99 rounds to 100. Casting always truncates the fraction. If a fee calculation or percentage looks "off by one" in your program, an accidental truncating cast is the first suspect.

Wrapper classes and autoboxing

Each primitive has an object twin: int/Integer, double/Double, boolean/Boolean and so on. Wrappers exist because generics and collections work only with objects — you write ArrayList<Integer>, never ArrayList<int>.

Java converts between the two automatically (autoboxing and unboxing), which keeps code clean but hides two traps: unboxing a null Integer throws NullPointerException, and == between two Integer objects compares references (with a confusing cache for values -128 to 127). Rule of thumb: compare wrappers with .equals(), and prefer primitives in fields and loops unless null is a meaningful state.

Choosing the right type: a decision guide

• Whole number, fits in ±2.14 billion → int
• Whole number, might not fit (IDs, timestamps, money in paise) → long
• Decimal for science/statistics → double
• Money → BigDecimal or long paise
• Yes/no state → boolean
• Text → String; single character → char
• Inside collections/generics → wrapper classes

Types are half the story of storing data — the other half is where and how you declare the variables that hold them, which is exactly where this series goes next. And if you are still setting up your environment, start from what is Java to get the toolchain in place first.