Data Types & Operators in Java

🎯 Learning Objectives

• Distinguish between primitive types (int, double, char, boolean) and reference types
• Declare, initialize, and use variables of all primitive types
• Perform type casting (widening and narrowing) safely
• Use arithmetic, relational, logical, assignment, and bitwise operators
• Understand overflow, underflow, and precision issues

📋 Prerequisites

• Java Introduction (week01/01-java-introduction.md): Compilation, JVM, Hello World
• BSCS1002 — Python: You've used variables and operators in Python; Java is more explicit about types

1. Intuition: Why Do We Need Types?

1.1 What Problem Does This Solve?

Why it matters: Static typing catches type errors at compile-time, not runtime. If you try to store "hello" in an int variable, javac refuses to compile. This eliminates entire categories of bugs before the program even runs.

1.2 Mental Model: Variables as Labeled Boxes

java
int age = 25;
    ↓
┌────────────────┐
│ age             │  ← label (variable name)
├────────────────┤
│      25         │  ← value (stored in memory)
└────────────────┘
  Size: 4 bytes
  Shape: can only hold integers

2. Primitive Types — The Building Blocks

2.1 The Eight Primitive Types

2.2 Important Details

java
int decimal = 42;        // Decimal (base 10)
int hex = 0x2A;          // Hexadecimal (base 16) — starts with 0x
int binary = 0b101010;   // Binary (base 2) — starts with 0b
int octal = 052;         // Octal (base 8) — starts with 0 (avoid confusion!)
int big = 1_000_000;     // Underscores for readability (Java 7+)

java
double d1 = 3.14;        // double by default
double d2 = 3.14d;       // explicit d suffix
float f1 = 3.14f;        // f suffix REQUIRED for float
double sci = 1.23e-4;    // Scientific notation: 0.000123

Common Mistake: float f = 3.14; fails because 3.14 is a double literal. Always add f suffix for floats. Character Literals:

java
char letter = 'A';       // Single quotes, NOT double
char digit = '9';        // Character 9, not integer 9
char newline = '\n';     // Escape sequence
char unicode = '\u0041'; // Unicode escape — same as 'A'

3. Reference Types — Objects That Live on the Heap

3.1 Primitive vs Reference

3.2 Memory Model

java
int x = 10;           // x on stack, value=10
String s = "Hello";   // s on stack → points to "Hello" on heap

3.3 The Special String Type

java
String s1 = "Hello";         // String literal (stored in string pool)
String s2 = "Hello";         // Reuses same object from pool
String s3 = new String("Hello"); // Forces new object on heap
System.out.println(s1 == s2);      // true — same reference
System.out.println(s1 == s3);      // false — different references
System.out.println(s1.equals(s3)); // true — same content

Key Insight: Always use .equals() to compare String content. The == operator only compares references (memory addresses), not the text inside.

4. Type Casting — Converting Between Types

4.1 Widening (Implicit) Casting

java
int myInt = 100;
long myLong = myInt;      // OK: int → long (widening)
double myDouble = myInt;  // OK: int → double (widening)
byte b = 50;
int i = b;                // OK: byte → int (widening)

4.2 Narrowing (Explicit) Casting

java
double pi = 3.14159;
int truncated = (int) pi;  // Explicit cast: double → int
System.out.println(truncated); // 3 (fractional part lost!)
long big = 1_000_000_000_000L;
int small = (int) big;
System.out.println(small); // Unpredictable — overflow!

4.3 Overflow Examples

java
int max = Integer.MAX_VALUE;   // 2,147,483,647
int overflow = max + 1;
System.out.println(overflow);  // -2,147,483,648 (wraps around!)
int underflow = Integer.MIN_VALUE - 1;
System.out.println(underflow); // 2,147,483,647 (wraps around!)

5. Operators in Java

5.1 Arithmetic Operators

5.2 Integer Division Trap — Common Mistake

java
int a = 5;
int b = 2;
double result = a / b;      // result = 2.0, NOT 2.5!
// Because a/b is integer division first (5/2=2), then promoted to double
double correct = (double) a / b;  // result = 2.5

5.3 Relational Operators

5.4 Logical Operators

java
String s = null;
if (s != null && s.length() > 0) {  // SAFE: short-circuit prevents null pointer
    System.out.println("Not empty");
}
if (s != null & s.length() > 0) {   // UNSAFE: & evaluates both sides — NullPointerException!
    System.out.println("Not empty");
}

5.5 Assignment Operators

5.6 Increment/Decrement Operators

java
int x = 5;
int y = ++x;    // x=6, y=6 (increment first)
int z = x++;    // x=7, z=6 (assign first, increment after)

5.7 Bitwise Operators

6. Java vs Python: Types & Operators

7. Common Pitfalls

Pitfall 1: Integer Division

java
double result = 5 / 2;  // result = 2.0, not 2.5!

Pitfall 2: Comparing Strings with ==

java
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1 == s2);  // false!

Pitfall 3: Float Without f Suffix

java
float f = 3.14;  // Compile error!

Pitfall 4: Overflow Without Warning

java
int population = 9_000_000_000;  // Compile error (too large for int)

Pitfall 5: Uninitialized Local Variables

java
int x;
System.out.println(x);  // Compile error!

8. Practice Questions

Q1: What is the output of this code?

java
int a = 10;
double b = 3.5;
int c = a + (int) b;
System.out.println(c);

Answer: 13

Reasoning:

1. (int) b casts 3.5 to 3 (truncation, not rounding)
2. a + 3 = 10 + 3 = 13
3. Result stored in int c, prints 13 Q2: What is the output?

java
int x = 5;
int y = x++ * 2;
System.out.println(x + ", " + y);

Answer: 6, 10

Reasoning:

1. x++ is post-increment: uses current value 5, then increments x to 6
2. y = 5 * 2 = 10
3. After the line, x = 6, y = 10 Q3: Explain the output

java
System.out.println(10 / 3);
System.out.println(10.0 / 3);
System.out.println(10 / 3.0);

Answer:

pseudo
3
3.3333333333333335
3.3333333333333335

1. 10 / 3: Both operands are int → integer division → 3
2. 10.0 / 3: One operand is double → floating-point division → 3.333...
3. 10 / 3.0: Same as above → 3.333... Q4: What is the value of result?

java
boolean result = (10 > 5) && (5 < 2) || (3 == 3);

Answer: true

Reasoning:

1. (10 > 5) = true
2. (5 < 2) = false
3. true && false = false
4. (3 == 3) = true
5. false || true = true

Operator precedence: && has higher precedence than ||, so (true && false) || true = false || true = true. Q5: Why does this code fail to compile?

java
public class Test {
    public static void main(String[] args) {
        int x;
        if (args.length > 0) {
            x = Integer.parseInt(args[0]);
        }
        System.out.println(x);
    }
}

Answer: Compilation error: "variable x might not have been initialized."

The compiler sees that x is only assigned inside the if block, which may not execute. Java requires all local variables to be definitely assigned before use. Fix by giving x a default value: int x = 0; Q6: What happens if you cast a large long to int?

java
long big = 1_000_000_000_000L;
int small = (int) big;
System.out.println(small);

Answer: The output is -727379968 (or some unexpected number).

Reasoning: long value 1,000,000,000,000 in binary is larger than the 32 bits an int can hold. The cast truncates to the lower 32 bits, which may result in a completely different value (including negative). There is no exception — Java silently truncates. Q7: What is the output?

java
System.out.println(5 & 3);
System.out.println(5 | 3);
System.out.println(5 ^ 3);
System.out.println(5 << 1);

Answer:

pseudo
1
7
6
10

Reasoning:

• 5 = 0101, 3 = 0011
• 0101 & 0011 = 0001 = 1
• 0101 | 0011 = 0111 = 7
• 0101 ^ 0011 = 0110 = 6
• 5 << 1 = 1010 = 10 (multiply by 2) Q8: What is the difference between && and & in Java?

Answer:

• && is short-circuit AND: if the left operand is false, the right operand is NOT evaluated
• & is non-short-circuit AND: both operands are always evaluated

Example:

java
String s = null;
if (s != null && s.length() > 0) { }  // Safe — short-circuit prevents NPE
if (s != null & s.length() > 0) { }   // Throws NullPointerException!

Q9: What is the range of a byte and why does Java use it?

Answer: A byte stores values from -128 to 127 (inclusive), using 1 byte (8 bits) of memory. It's used when:

1. Working with raw binary data (file I/O, network protocols)
2. Saving memory in large arrays (e.g., byte[] vs int[] saves 75% memory)
3. Interacting with systems that use 8-bit data

Range calculation: 2⁸ = 256 possible values. Since Java uses two's complement for negatives: -128 to 127. Q10: What are the default values for primitives in Java?

Answer (applies to fields, NOT local variables):

• byte, short, int: 0
• long: 0L
• float: 0.0f
• double: 0.0d
• char: '\u0000' (null character)
• boolean: false
• Any reference type: null

Local variables do NOT get default values — they must be explicitly initialized before use.

📐 Key Formulas / Concepts

🔗 Cross-References

• Next: Memory Model — how stack and heap work
• Control Flow: week01/04-control-flow.md
• Python Comparison: BSCS1002 — Python Variables & Data Types
• Reference: Oracle Java Tutorials — Primitive Data Types Join Discord Previous1.1 Java IntroductionNext1.3 Memory Model