ICSE Class 10 Java Basics: Data Types & Variables Explained

Why Java Data Types & Variables Matter

Ever wondered how a game keeps score or how a calculator remembers numbers? Behind every Java program are tiny containers called variables that store data – and the type of data they hold decides what you can do with it.

💡 In Simple Words: A variable is like a labeled jar where you can put something – a number, a letter, or even a whole sentence. The data type tells you what kind of thing the jar is meant for, so you don’t try to pour water into a jar made for marbles.

What Is a Variable?

A variable is a named memory slot that your program can read from or write to. Think of it as a post‑it note stuck on your desk: you write a value on it, and later you can look at it or change it.

Declaring a Variable

Before you can use a variable, you must tell Java its data type and give it a name. This is called declaring the variable.

int score;               // declares an integer variable named score
String playerName;      // declares a text (String) variable named playerName

Initializing and Re‑assigning

After declaration you usually give the variable a starting value – this is initializing. Later you can change (re‑assign) the value.

score = 0;               // first value (initialization)
score = score + 5;       // re‑assigning after gaining points

Java Data Types: The Building Blocks

Java splits data types into two families: primitive types (the simplest, built‑in kinds) and reference types (objects, arrays, and strings that point to more complex data).

Primitive Types

These are the raw ingredients – numbers, single characters, and true/false values. They are stored directly in the variable’s memory slot.

Reference Types

When you need something bigger than a single number – like a whole sentence, a list of scores, or a custom object – you use reference types. The variable holds a *reference* (think of it as an address) to the actual data stored elsewhere.

String greeting = "Hello, world!";   // reference type holding text
int[] marks = {85, 90, 78};        // array reference holding three integers

How to Choose the Right Type

• Use int for whole numbers that fit within ±2 billion.
• Pick long when the numbers might exceed that range (e.g., population counts).
• Choose float or double for measurements; double is more precise.
• Use char for a single letter or symbol.
• Pick boolean for yes/no questions.
• Whenever you need text, go with String – it’s a reference type that behaves like a sentence.

Quick Flow: From Declaration to Use

Common Mistakes to Avoid

• Forgetting to end each statement with a semicolon (;).
• Mixing up int and double – adding a decimal to an int causes a compile error.
• Using a variable before giving it a value (uninitialized variable).
• Trying to store a number larger than the chosen type’s range.

📝 Likely Exam Questions

1. What is a variable in Java and why must you declare its data type?
   A variable is a named memory location that holds a value. Declaring its data type tells Java how much space to reserve and what operations are allowed.
2. List all eight primitive data types in Java with one example each.
   byte (e.g., 100), short (20000), int (12345), long (9_000_000_000L), float (3.14f), double (3.14159), char ('A'), boolean (true).
3. Write a short code snippet that declares a double variable named price, initializes it to 49.99, then increases it by 10%.
   

   double price = 49.99;
   price = price * 1.10; // adds 10%

4. Explain the difference between primitive and reference types.
   Primitive types store the actual value directly in the variable’s memory slot. Reference types store an address that points to the actual object stored elsewhere on the heap.
5. What will happen if you try to assign a value larger than 127 to a byte variable?
   The compiler will throw an error because the value exceeds the byte’s range (-128 to 127).