Java Data Types: Primitive Values and Reference-Based Types

A data type tells Java what kind of value a variable can hold, how much memory to reserve, and which operations make sense. When you write int age = 25; the word int is the instruction that everything else depends on.

byte smallNumber = 25;
// small box, saves memory
long hugeNumber = 9876543210L;
double price = 1499.99;
boolean isAvailable = true;

Java is strongly typed, which means the compiler checks the type of every variable and every expression for you. Store a String in an int and the program never compiles. That strictness sounds annoying for the first few days, then it turns into the thing you rely on most.

Choosing the right type matters for three reasons.

• Memory. An int array of a million numbers uses four million bytes, while a byte array uses one million. In large systems that difference adds up quickly.

• Correctness. The type defines the range of values you can store, so the wrong type can silently overflow.

• Clarity. Reading double temperature tells a colleague that decimals are expected, while reading double value says nothing.

Every data type in Java belongs to one of two families, and knowing which family you are in explains most of the language's behaviour.

JAVA DATA TYPES +--------------------------------------+ +--------------------------------+ | PRIMITIVE TYPES(8) | | REFERENCE TYPES | | | | | | byte short int long | | your own classes | | float double char boolean | | String, ArrayList, Integer | | | | arrays, interfaces, enums | | * raw value stored directly | | records, lambdas | | * fixed size | | * address of an object | | * can NEVER be null | | * CAN be null | | * no methods | | * have methods | +--------------------------------------+ +--------------------------------+

The single most practical difference is null. A primitive always holds a real value, so the compiler guarantees you will never face a missing value. A reference type can point at nothing, which is exactly what causes the NullPointerException that every Java developer meets at least once.

The second difference is size. A primitive occupies a fixed, known number of bytes. An object can be any size, because it carries a header plus whatever fields and methods it needs.

This one table is worth bookmarking. It covers every primitive you will use for years.

Two details catch people out. First, char is unsigned in Java, so it never goes negative. Second, the specification does not fix the size of boolean, so do not build anything that depends on it being exactly one byte.

byte, short, int and long all hold whole numbers with no decimal part. They differ only in size, which means the same value can be held by any of them.

public class IntegerTypes {
    public static void main(String[] args) {
        byte sensorReading = 120;
        // fits comfortably
        short temperature = -450;
        // also fine
        int itemCount = 250_000;
        // underscores are allowed
        long transactionId = 9_876_543_210L;
        System.out.println(sensorReading + " " + temperature);
        System.out.println(itemCount + " " + transactionId);
        byte overflow =(byte) 130;
        // wraps around to -126
        System.out.println("byte holding 130 becomes " + overflow);
    }
}

• int is the default type for a whole-number literal, so long values need an L suffix.

• Overflow wraps around rather than throwing, which is why large calculation bugs are so hard to spot.

• Java 7 and later allow underscores in numeric literals for readability, as in 250_000.

The two floating-point types store numbers with a decimal point. They differ mainly in how many significant digits they can keep accurately.

Because decimals cannot be written exactly in binary, some values are stored as an approximation. That single fact causes an enormous number of beginner bugs.

public class FloatingPointDemo {
    public static void main(String[] args) {
        double sum = 0.1 + 0.2;
        // people expect 0.3
        System.out.println(sum);
        // prints 0.30000000000000004
        float a = 0.1f;
        double b = a;
        // 0.10000000149011612
        double regular = 3.14;
        // this is a double, not a float
        float forced = 3.14f;
        // the f suffix forces a float
        System.out.println("regular=" + regular + ", forced=" + forced);
    }
}

• Never use float or double for money. Use java.math.BigDecimal, which stores decimal values exactly.

• Write an L or l suffix on large whole numbers, and an f suffix when you specifically want a float.

• A scientific literal such as 1.5e10 is a double unless you add the f suffix.

A char holds exactly one character and is written with single quotes. It uses 16-bit UTF-16 encoding, which is why it can represent far more than the English alphabet.

public class CharDemo {
    public static void main(String[] args) {
        char grade = 'A';
        char rupee = '₹';
        char smiley = '☕';
        System.out.println(grade + " " + rupee + " " + smiley);
        System.out.println("grade as a number = " +(int) grade);
        // 65
        char next;
        next =(char)(grade + 1);
        // cast is required
        System.out.println("next grade = " + next);
        // B
        // System.out.println(grade + 1);   // ERROR: char and int do not mix
    }
}

• char uses single quotes, String uses double quotes. char c = 'a'; and String s = "a"; are different things.

• Java will not do arithmetic with char directly. Cast to int first, then convert back.

• char is unsigned, so its range is 0 to 65,535 and it never goes negative.

The boolean type has only two possible values: true and false. It is the type behind every if statement and every yes-or-no answer in your program.

public class BooleanDemo {
    public static void main(String[] args) {
        boolean isJavaFun = true;
        boolean hasError = false;
        if (isJavaFun && !hasError) {
            System.out.println("Ready to build");
        } // int total = true;        // ERROR: boolean cannot be used as a number
        // System.out.println(true + 1);   // ERROR for the same reason
    }
}

• In many older languages like C, a boolean is really a number. Java is strict here: it will not compile.

• Use boolean rather than int flags such as isActiveFlag = 1, because the name itself documents the meaning.

Anything that is not one of the eight primitives is a reference type. That list is longer than most beginners expect, and it contains two famous surprises.

• Your own classes are reference types, obviously.

• Arrays are reference types, so int[] can be null even though the int elements can never be null.

• String is a reference type, not a primitive. This surprises anyone arriving from C.

• Interfaces, enums, records and even lambdas are all reference types.

public class ReferenceTypesDemo {
    public static void main(String[] args) {
        String[] names = new String[] {
            "Asha", "Bilal", "Chandra"
        };
        int[] numbers = new int[3];
        // array is null-able, elements are not
        numbers[0] = 10;
        String missingName = null;
        // legal, because String is a reference
        // int missingNumber = null;       // ERROR, int is a primitive
        for (String name : names) {
            System.out.println(name);
        } System.out.println("missingName is null? " +(missingName == null));
        System.out.println("numbers[1] default = " + numbers[1]);
        // 0
    }
}

An array is the interesting case, because the container and the contents follow different rules. The array reference can be null, every reference element inside it can be null, and yet the primitive elements are quietly filled with their default values.

Java cannot put a primitive directly inside a generic class such as ArrayList, because generics only accept objects. For each primitive, Java provides a wrapper class.

Java 5 introduced autoboxing, which converts between a primitive and its wrapper automatically, so you rarely write the conversions by hand.

import java.util.ArrayList;
import java.util.List;
public class AutoboxingDemo {
    public static void main(String[] args) {
        List numbers = new ArrayList();
        numbers.add(10);
        // int is boxed to Integer
        int total = 0;
        for (Integer value : numbers) {
            total += value;
            // unboxed automatically
        } Integer safe = 127;
        Integer other = 127;
        System.out.println("value " + safe + " equals " + other + "? " + safe.equals(other));
        System.out.println("total = " + total);
        System.out.println("int max = " + Integer.MAX_VALUE);
        System.out.println("parsed  = " + Integer.parseInt("500"));
    }
}

• Use equals rather than == on wrappers, because == compares references.

• Small values from -128 to 127 are cached, so those boxes may share one object.

• Wrapper classes give you the exact range of each primitive, as in Long.MIN_VALUE.

Fields and array elements receive a default value automatically. Local variables receive nothing at all, which is exactly why the compiler insists you assign them yourself.

public class DefaultValues {
    int number;
    double price;
    char grade;
    String title;
    public static void main(String[] args) {
        DefaultValues d = new DefaultValues();
        System.out.println("number=" + d.number + " price=" + d.price);
        System.out.println("gradeCode=" +(int) d.grade + " title=" + d.title);
        int[] scores = new int[3];
        // every element gets 0
        System.out.println(scores[0] + " " + scores[1] + " " + scores[2]);
        int local;
        // ERROR if you print it unassigned
        // System.out.println(local);
        local = 7;
        System.out.println("local=" + local);
    }
}

Java converts between numeric types automatically in one direction, and only with your permission in the other.

WIDENING IS AUTOMATIC AND ALWAYS SAFE

   byte ---> short ---> int ---> long ---> float ---> double
                    ^
                    |
            char ---+          char also widens into int

NARROWING NEEDS AN EXPLICIT CAST AND CAN LOSE DATA

   double ---> float ---> long ---> int ---> short ---> byte

public class TypeConversionDemo {
    public static void main(String[] args) {
        byte small = 100;
        int widened = small;
        // automatic, no data lost
        long wider = small;
        // automatic again
        double widest = small;
        // automatic, still correct
        System.out.println(widened + " " + wider + " " + widest);
        int big = 300;
        byte narrow =(byte) big;
        // explicit cast, wraps to 44
        System.out.println("300 as byte = " + narrow);
        double decimal = 9.99;
        int truncated =(int) decimal;
        // cast truncates, does not round
        System.out.println("9.99 as int = " + truncated);
        // System.out.println(decimal);     // ERROR: double cannot go into int
    }
}

• Widening never loses information, so the compiler allows it silently.

• Narrowing may lose data, so Java makes you write the cast to prove you meant it.

• A cast to int truncates rather than rounding, so 9.99 becomes 9.

Almost every beginner hits one of these at least once, and most of them produce a confusing error message.

• The most expensive mistake in the list is the float or double money bug, because it looks correct right up until an accountant finds it.

• Use Integer.parseInt to turn text into a number, and String.valueOf to turn a number into text.

• Never write a decimal without thinking about the type. It defaults to double, which is usually what you want.

A simple decision guide saves a lot of second-guessing later.

WHAT ARE YOU STORING? | +-- a whole number that can be negative? | +-- small, -128 to 127 .............. byte | +-- fits in -32,768 to 32,767 ....... short | +-- almost certainly yes ........... int

• Default to int and double. Move to long or BigDecimal only when a real requirement appears.

• Use final where the value should never change, so the compiler helps you keep the promise.

• Prefer a specific type such as String or LocalDate over Object in application code.

The whole topic compressed into one screen.

With the type system clear in your head, the next topic, Java literals, becomes obvious, because a literal is simply the literal value you write at a particular type.