Primitive Types

2.1.1 What Are Primitive Types?

Primitive types are the most basic data types built directly into the Java language.
They represent simple, low-level values like numbers, characters, and boolean logic.
Unlike objects, primitive types do not come with methods or complex behaviors — they store raw data in the most efficient way possible.

Java has exactly eight primitive types: byte, short, int, long, float, double, char, and boolean.
Each type is designed for a specific purpose, such as whole numbers, floating-point numbers, single characters, or true/false values.

Understanding primitive types is essential because they form the building blocks of all Java applications.
They handle the core operations of programs with minimal overhead, ensuring speed and memory efficiency.

Mini Lab

java
public class PrimitiveExample {
    public static void main(String[] args) {
        int age = 25;
        double price = 19.99;
        char grade = 'A';
        boolean isOpen = true;

        System.out.println("Age: " + age);
        System.out.println("Price: " + price);
        System.out.println("Grade: " + grade);
        System.out.println("Is Open: " + isOpen);
    }
}

2.1.2 Key Characteristics of Primitive Types

Primitive types in Java are not objects — they live on the stack, not the heap.
This means they do not carry extra information like metadata or methods, which makes them fast and lightweight.

Each primitive type has a fixed size, defined by the Java language specification:

• int: 32 bits

• long: 64 bits

• float: 32 bits (IEEE 754)

• double: 64 bits (IEEE 754)

• char: 16 bits (Unicode)

• boolean: true/false (size depends on JVM implementation)

• byte: 8 bits

• short: 16 bits

Because of their predictable size and behavior, primitive types are perfect for tasks that require performance and precision, such as calculations, loops, and comparisons.

Mini Lab

java
public class PrimitiveSizes {
    public static void main(String[] args) {
        System.out.println("int: " + Integer.BYTES + " bytes");
        System.out.println("long: " + Long.BYTES + " bytes");
        System.out.println("float: " + Float.BYTES + " bytes");
        System.out.println("double: " + Double.BYTES + " bytes");
        System.out.println("char: " + Character.BYTES + " bytes");
    }
}

2.1.3 Using Primitive Types Effectively

When writing Java code, choosing primitive types over objects where possible can greatly improve performance.
For example, using int instead of Integer avoids unnecessary boxing and unboxing, saving both CPU time and memory.

Primitive types are also the foundation for control structures like if statements and loops, where simple comparisons or counters are needed.
Understanding how primitives interact with operators (arithmetic, comparison, logical) is critical for writing clear and efficient logic.

Finally, although primitive types are simple, they interact closely with Java’s object system through wrapper classes (like Integer, Double, Boolean).
Knowing when to stick with primitives and when to use wrappers — for example, when working with collections that can’t hold primitives — is an important skill for any Java web developer.

Mini Lab

java
public class PrimitiveVsWrapper {
    public static void main(String[] args) {
        int primitiveInt = 10;
        Integer wrapperInt = primitiveInt; // Autoboxing

        System.out.println("Primitive int: " + primitiveInt);
        System.out.println("Wrapper Integer: " + wrapperInt);

        // Using primitive in a loop
        for (int i = 0; i < 5; i++) {
            System.out.println("Counter: " + i);
        }
    }
}