Variables & Data Types

What Are Variables and Data Types?

A variable is a named container that holds a value your program can read and modify. Every variable has a data type that tells the JVM two things: what kind of value it can hold, and how much memory to allocate for it. Without variables there is no program — they are the fundamental mechanism for storing state.

In Java, you must declare the type of a variable before you use it. This is what static typing means: the type is known at compile time, not discovered at runtime. The compiler uses that information to catch errors before your code ever runs — trying to store a text string in an integer variable is rejected immediately, not after deployment.

// Every variable declaration has three parts:
            //   type       name     value
                int        age    = 25;
                String     name   = "Alice";
                boolean    active = true;
                double     price  = 19.99;
            
            // The compiler rejects mismatches immediately:
            int count = "hello";  // compile error: incompatible types
            int count;
            System.out.println(count);  // compile error: variable might not be initialised

The data type also determines what operations are valid. You can do arithmetic on an int, call .toUpperCase() on a String, and compare a boolean with if — but not the other way around. This is the contract the type system enforces.

Java's Type System

Java is statically typed: every variable has a declared type fixed at compile time. The compiler rejects type mismatches before the code ever runs. All types fall into two categories:

• Primitive types — 8 built-in types (int, boolean, double…). Store actual values. Cannot be null. Live on the stack.
• Reference types — everything else (classes, arrays, interfaces). Store a memory address pointing to an object on the heap. Can be null.

How Variables Live in Memory

This is the most important mental model in Java. Get it wrong and NullPointerExceptions and unexpected mutations will haunt you.

/*
 *  JVM MEMORY — Variable Storage
 *  ================================
 *
 *  ┌──────────────────────────────────────────────────────────────┐
 *  │  STACK (per thread)                                          │
 *  │                                                              │
 *  │  Method frame: main()                                        │
 *  │  ┌───────────┬────────┐                                      │
 *  │  │  int age  │   25   │  ← Primitive: VALUE stored directly  │
 *  │  ├───────────┼────────┤                                      │
 *  │  │  name     │ 0x742  │  ← Reference: ADDRESS to heap object │
 *  │  └───────────┴───┬────┘                                      │
 *  └──────────────────┼───────────────────────────────────────────┘
 *                     │
 *  ┌──────────────────▼───────────────────────────────────────────┐
 *  │  HEAP (shared by all threads)                                │
 *  │                                                              │
 *  │  0x742: ┌────────────────────────────┐                       │
 *  │         │ String "Alice"             │                       │
 *  │         │   value: ['A','l','i','c'] │                       │
 *  │         └────────────────────────────┘                       │
 *  └──────────────────────────────────────────────────────────────┘
 *
 *  PRIMITIVES → value on stack (fast, no pointer lookup)
 *  REFERENCES → address on stack, object on heap (GC managed)
 */

The assignment trap: primitives vs references

// PRIMITIVES: assignment copies the VALUE
int a = 10;
int b = a;    // b gets its own copy of 10
b = 20;
System.out.println(a);  // Still 10. a is unaffected.

// REFERENCES: assignment copies the ADDRESS (same object!)
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;    // arr2 points to the SAME array
arr2[0] = 999;
System.out.println(arr1[0]);  // 999 — arr1 sees the change!

Primitive Data Types

Java has exactly 8 primitives. Sizes are platform-independent — an int is always 32 bits on every JVM, unlike C/C++.

// Integer literals — Java 7+ allows underscores for readability
int million = 1_000_000;
long timestamp = 1_716_000_000_000L;  // L suffix required for long literals > int range
int hex = 0xFF;                         // 255
int binary = 0b1010_0011;              // 163

// Floating point
double pi = 3.141592653589793;         // double is the default
float price = 19.99f;                  // f suffix required for float literals

// char is numeric — arithmetic works
char c = 'A';
System.out.println((int) c);       // 65
System.out.println((char)(c + 1)); // B

// boolean: integers are NOT valid in Java (unlike C/C++)
// if (1) { }  // ERROR — only true/false allowed

BigDecimal price = new BigDecimal("19.99");   // ✅ exact
BigDecimal wrong = new BigDecimal(19.99);    // ❌ inherits float imprecision

Reference Types: String, Arrays, Wrappers

String

String is immutable — every "modification" creates a new object. String literals are interned in the String Pool; new String(...) always creates a heap object.

// Literals go to the String Pool
String name = "John Doe";

// Useful methods
name.length();                      // 8
name.toUpperCase();                 // "JOHN DOE"
name.contains("Doe");              // true
name.replace("John", "Jane");      // "Jane Doe"
name.split(" ");                    // ["John", "Doe"]
"  hello  ".strip();               // "hello" (Java 11+, Unicode-aware)

// Text blocks — Java 15+
String json = """
    {
        "name": "John",
        "age": 30
    }
    """;

// Formatting — Java 15+
String msg = "Hello %s, you are %d".formatted(name, 30);

// ❌ WRONG: == compares references, not content
String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2);       // false
System.out.println(s1.equals(s2));  // true
System.out.println(Objects.equals(s1, s2));  // true + null-safe

// StringBuilder for building strings in loops
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10_000; i++) sb.append("a");
String result = sb.toString();
// String concatenation in a loop creates 10,000 intermediate objects — use StringBuilder

Arrays

// Declaration and initialisation
int[] numbers = {1, 2, 3, 4, 5};
int[] scores = new int[10];          // All zeros by default
String[] names = {"Alice", "Bob"};

// Arrays are fixed-size — use List for dynamic collections
numbers[0];                           // 1 (0-indexed)
numbers[numbers.length - 1];         // last element
numbers.length;                       // field, not method!

// 2D array
int[][] matrix = {{1,2},{3,4}};
int val = matrix[1][0];               // 3

Wrapper Classes

Each primitive has an object wrapper needed for generics and collections. Java handles conversion automatically via autoboxing/unboxing.

List<Integer> list = new ArrayList<>();
list.add(42);        // Autoboxing: int → Integer
int x = list.get(0); // Unboxing: Integer → int

// Useful utility methods
int parsed  = Integer.parseInt("123");
String bin  = Integer.toBinaryString(42);   // "101010"
int max     = Integer.MAX_VALUE;              // 2,147,483,647
boolean dig = Character.isDigit('5');        // true

// ❌ DANGER: unboxing null throws NullPointerException
Integer maybeNull = null;
int value = maybeNull;  // NullPointerException at runtime!

// ✅ SAFE
int value = (maybeNull != null) ? maybeNull : 0;
int value = Optional.ofNullable(maybeNull).orElse(0);

var, final and Scope

Local variable type inference: var (Java 10+)

// var: compiler infers type from the right-hand side
var name   = "Alice";                             // String
var age    = 25;                                  // int
var prices = new ArrayList<Double>();            // ArrayList<Double>
var map    = Map.of("a", 1);                     // Map<String, Integer>

// var restrictions — all compile errors:
// var x;                 no initialiser
// var nothing = null;    cannot infer from null
// var nums = {1, 2, 3};  cannot infer array type
// Only for local variables — not fields, params, return types

final variables and constants

// final local variable: cannot be reassigned after first assignment
final int MAX_RETRIES = 3;
// MAX_RETRIES = 5;  // ERROR

// Class-level constant: public static final + UPPER_SNAKE_CASE
public static final int    DEFAULT_TIMEOUT_MS = 30_000;
public static final String DB_URL = "jdbc:mysql://localhost:3306/mydb";

// IMPORTANT: final on a reference freezes the reference, NOT the object
final List<String> names = new ArrayList<>();
names.add("Alice");            // ✅ modifying the object is allowed
// names = new ArrayList<>(); // ❌ reassigning the reference is not

Variable scope

public class ScopeExample {
    private static int classCounter = 0;       // class scope — shared by all instances
    private String instanceField = "hello";   // instance scope — each object gets its own

    public void doWork(String param) {          // param: method scope
        int local = 10;                          // method scope

        for (int i = 0; i < 5; i++) {           // i: loop scope only
            int loopVar = i * 2;               // loopVar: loop scope only
        }
        // i and loopVar not accessible here
    }
}

Type Conversion

Widening (implicit) — no data loss

// byte → short → int → long → float → double (automatic)
byte b = 10;
int i = b;        // automatic
double d = i;     // automatic

// ⚠️ Arithmetic promotes operands to at least int
byte b1 = 10, b2 = 20;
// byte result = b1 + b2;  // ERROR: b1+b2 is int
int result = b1 + b2;     // OK

Narrowing (explicit cast) — may lose data

double d = 100.99;
int i = (int) d;          // 100 — decimal part silently lost

int big = 130;
byte small = (byte) big;  // -126 — overflow! 130 doesn't fit in byte

// Safe pattern: validate range before casting
long value = getSomeValue();
if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) {
    int safe = (int) value;
} else {
    throw new ArithmeticException("Value out of int range");
}

String conversions

// Primitive → String
String s = String.valueOf(42);        // preferred
String s = Integer.toString(42);      // also fine

// String → Primitive
int     n = Integer.parseInt("123");
double  d = Double.parseDouble("3.14");
boolean b = Boolean.parseBoolean("true");
long    l = Long.parseLong("999999999999");

// Always guard parsing — throws NumberFormatException on bad input
try {
    int val = Integer.parseInt(userInput);
} catch (NumberFormatException e) {
    // handle gracefully
}

Naming Conventions

// ❌ BAD: vague, single letters, type prefixes
int x = 42;
String strName = "John";
boolean flag = true;

// ✅ GOOD: intention-revealing, no type in name
int userAge = 42;
String customerName = "John";
boolean isEmailVerified = true;

Common Pitfalls

double result = 5 / 2;    // 2.0, NOT 2.5 — both operands are int
double result = 5 / 2.0;  // ✅ 2.5 — one operand is double
double result = (double) 5 / 2;  // ✅ 2.5

int overflow = Integer.MAX_VALUE + 1;  // -2,147,483,648 (wraps!)

// ✅ Use Math.addExact() — throws ArithmeticException on overflow
int safe = Math.addExact(Integer.MAX_VALUE, 1);

// ✅ Or use long
long result = (long) Integer.MAX_VALUE + 1;

String a = "hello";
String b = new String("hello");
a == b;             // false — different objects
a.equals(b);        // true — same content
Objects.equals(a, b); // ✅ true + null-safe

double sum = 0.1 + 0.2;
sum == 0.3;   // false! (sum is 0.30000000000000004)

// ✅ Compare with epsilon
Math.abs(sum - 0.3) < 1e-10;   // true

// ✅ Or use BigDecimal for exact arithmetic
new BigDecimal("0.1").add(new BigDecimal("0.2"))
    .equals(new BigDecimal("0.3"));  // true

Senior Topics: Performance and Hidden Traps

Autoboxing performance cost

// ❌ SLOW: Integer wrapper creates objects on every iteration
Integer sum = 0;
for (int i = 0; i < 1_000_000; i++) {
    sum += i;  // unbox, add, rebox — allocates ~1M Integer objects
}

// ✅ FAST: primitive, no allocation
int sum = 0;
for (int i = 0; i < 1_000_000; i++) {
    sum += i;
}
// ~10-15x faster. Use primitives in hot paths.

The Integer cache trap (classic senior interview question)

// JVM caches Integer instances from -128 to 127
Integer a = 127;
Integer b = 127;
System.out.println(a == b);   // true — same cached object

Integer c = 128;
Integer d = 128;
System.out.println(c == d);   // false — different objects, outside cache

// Lesson: NEVER use == to compare Integer objects.
// Always use .equals() or unbox to int first.

Modern alternative: records (Java 16+)

When you need a typed data carrier, prefer record over a class with fields. Records are immutable by default, generate equals(), hashCode() and toString() automatically, and make intent explicit.

// ❌ Old way: boilerplate class with fields
public class Point {
    private final int x;
    private final int y;
    // constructor, getters, equals, hashCode, toString... 40 lines
}

// ✅ Modern: record — one line, same behaviour
record Point(int x, int y) {}

Point p = new Point(10, 20);
p.x();         // accessor (no "get" prefix in records)
p.equals(new Point(10, 20));  // true — structural equality generated

Interview Questions