Primitive data types (int, double, char, boolean…)

The marks sheet that broke

What are primitive data types?

Words you'll meet in this lesson

The eight primitives

Four families, and how to write their values

Writing literals

Choosing the right type: a checklist

1. Is it true/false?

   Use boolean: isPaid, hasDiscount, passed.

   The JVM usually stores a boolean field in a byte, and boolean arrays use one byte per element, but the language never lets you treat it as a number.

2. Is it a single character?

   Use char: a grade, a gender code, a menu option. For words and sentences, use String (next lesson).

   'A' is stored as the number 65 in 16 bits: 0000 0000 0100 0001.

3. Is it a whole number?

   Default to int. If it could exceed about 2.1 billion (bank balances in paise, file sizes, timestamps in milliseconds, IDs in big systems), use long.

   Arithmetic is done in at least 32 bits anyway: byte + byte produces an int. byte and short mainly save memory in large arrays.

4. Does it have a decimal part?

   Use double for measurements: percentages, distances, temperatures.

   A double stores a sign bit, 11 exponent bits and 52 fraction bits. Most decimal fractions, like 0.1, have no exact binary form, so tiny rounding errors appear.

5. Is it money?

   Don't use double. Store paise in a long, or use BigDecimal (Module 10).

   ₹0.10 + ₹0.20 as doubles gives 0.30000000000000004. In a bank, those tiny errors add up across millions of transactions.

Inside the boxes: the bits behind each value

Left: the code and what it prints. Right: the actual bits in memory.

Picking types in real systems

Wrong type choices are behind some famous software bugs. Here's how real systems choose.

Watch it with an example: when the box is too small

A video app counts views in an int. A shop adds prices in double. Both hit a surprise. Watch what happens to the bits, and the fix.

Examples are simplified to show type choices. Each company's design varies.

Riya's marks sheet, with the right types

public class Main {
    public static void main(String[] args) {
        byte age = 20;
        int rollNo = 2041;
        long aadhaarLikeId = 9_876_543_210L;
        double percentage = 87.5;
        char grade = 'A';
        boolean passed = percentage >= 40;

        System.out.println("Age: " + age + ", Roll: " + rollNo);
        System.out.println("ID: " + aadhaarLikeId);
        System.out.println("Percentage: " + percentage + ", Grade: " + grade);
        System.out.println("Passed: " + passed);
        System.out.println("int max: " + Integer.MAX_VALUE);
    }
}

• byte age = 20;Ages fit easily in a byte (−128 to 127).
• 9_876_543_210LBigger than int's maximum, so it needs long and the L suffix. Underscores are just for reading.
• double percentage = 87.5;Decimal values default to double.
• char grade = 'A';Single quotes for one character. Double quotes would make a String.
• percentage >= 40A comparison: its result is a boolean, stored in passed.

Six types in one frame, and an overflow

All these primitives live directly in main's stack frame: no arrows, no heap objects (except the strings we print).

Worked examples: real problems, solved and traced in memory

Choosing the right primitive type is a real design decision: too small and numbers overflow, decimals in double aren't exact, and char is secretly a number. Each program below shows one of these in action.

stock 42, sold 3,200,000,000 (all time), price 1499.00, rating 4.3, size 'M', in stock

Stock 42, sold 3200000000
Price 1499.0, rating 4.3, size M, available true

0.10 added three times

double: 0.30000000000000004 (equals 0.3? false)
paise:  30 = Rs 0.30

row 'C', move 2 rows back

Row C has code 67
Two rows back: E

Check yourself

Quick revision

Interview and viva questions

Practice problems

Pick the right primitive type, and see each type's limits and quirks. Every output is fixed. The last three are business tasks.

(none)

10 300 70000 9000000000 2.5 3.14159 J true

public class Main {
    public static void main(String[] args) {
        byte b = 10; short s = 300; int i = 70000; long l = 9000000000L;
        float f = 2.5f; double d = 3.14159; char c = 'J'; boolean ok = true;
        System.out.println(b + " " + s + " " + i + " " + l + " " + f + " " + d + " " + c + " " + ok);
    }
}

(none)

-128 to 127

public class Main {
    public static void main(String[] args) {
        System.out.println(Byte.MIN_VALUE + " to " + Byte.MAX_VALUE);
    }
}

'A', 'a'

65 97

public class Main {
    public static void main(String[] args) {
        System.out.println((int) 'A' + " " + (int) 'a');
    }
}

7, 2

3
3.5

public class Main {
    public static void main(String[] args) {
        System.out.println(7 / 2);
        System.out.println(7 / 2.0);
    }
}

127

-128

public class Main {
    public static void main(String[] args) {
        byte level = 127;
        level++;
        System.out.println(level);
    }
}

249.50

Rs 249.50

public class Main {
    public static void main(String[] args) {
        long paise = 24950;
        System.out.println("Rs " + paise / 100 + "." + paise % 100);
    }
}

0, 15

In stock: false
In stock: true

public class Main {
    public static void main(String[] args) {
        int units = 0;
        boolean inStock = units > 0;
        System.out.println("In stock: " + inStock);
        units = 15;
        inStock = units > 0;
        System.out.println("In stock: " + inStock);
    }
}

8000000 × 365

Yearly visits: 2920000000

public class Main {
    public static void main(String[] args) {
        long daily = 8_000_000;
        System.out.println("Yearly visits: " + daily * 365);
    }
}

Real-world scenario questions (asked in company interviews)

Type choices look small, but they cause real money and data problems. Decide your answer first, then open the model answer.