Java Language Specification — Type Casting¶

int i = 300;
byte b = (byte) i;   // 300 = 256 + 44; low 8 bits = 44
System.out.println(b);   // 44

int j = -129;
byte b2 = (byte) j;  // -129 mod 256 = 127
System.out.println(b2);  // 127

System.out.println((int) 1.9999);   // 1 (truncated, not rounded)
System.out.println((int) -1.9999);  // -1 (toward zero, not -2)
System.out.println((int) Float.NaN); // 0
System.out.println((int) 1e18);     // 1000000000 (capped at MAX_VALUE... wait)
// Actually: (int) 1e18 is Integer.MAX_VALUE = 2147483647

Integer a = 127;
Integer b = 127;
System.out.println(a == b);    // true (cached)

Integer c = 128;
Integer d = 128;
System.out.println(c == d);    // false (NOT cached — different objects)
System.out.println(c.equals(d)); // true

byte x = 10;
byte y = 20;
// byte z = x + y;   // COMPILE ERROR: int cannot be converted to byte
byte z = (byte)(x + y);  // explicit cast required
int sum = x + y;         // widened to int automatically

@SuppressWarnings("unchecked")
List<String> strings = (List<String>) getRawList();  // unchecked cast
// ClassCastException may occur much later when iterating

record Point(int x, int y) {}
Object obj = new Point(3, 4);
if (obj instanceof Point(int x, int y)) {
    System.out.println("x=" + x + " y=" + y);  // deconstructs record
}

// Example 1: Widening and Narrowing Primitives
// File: PrimitiveCasts.java
public class PrimitiveCasts {
    public static void main(String[] args) {
        // Widening (implicit)
        byte b = 42;
        short s = b;   // byte → short
        int i = s;     // short → int
        long l = i;    // int → long
        float f = l;   // long → float (potential precision loss!)
        double d = f;  // float → double

        System.out.println("double: " + d);

        // Narrowing (requires explicit cast)
        double pi = 3.14159;
        int piInt = (int) pi;       // truncation: 3
        byte piByte = (byte) piInt; // truncation: 3 (fits)

        System.out.println("pi truncated: " + piInt);

        // Tricky narrowing
        int big = 300;
        byte small = (byte) big;   // 44 (bit truncation)
        System.out.println("300 as byte: " + small);

        // float-to-int truncation (not rounding)
        System.out.println("(int) 2.9 = " + (int) 2.9);    // 2
        System.out.println("(int) -2.9 = " + (int) -2.9);  // -2

        // Special float values to int
        System.out.println("NaN→int: " + (int) Double.NaN);                    // 0
        System.out.println("Inf→int: " + (int) Double.POSITIVE_INFINITY);      // 2147483647
        System.out.println("-Inf→int: " + (int) Double.NEGATIVE_INFINITY);     // -2147483648
    }
}

// Example 2: Reference Casting
// File: ReferenceCasts.java
public class ReferenceCasts {

    static class Animal {
        String sound() { return "..."; }
    }

    static class Dog extends Animal {
        @Override String sound() { return "Woof"; }
        String fetch() { return "Fetching!"; }
    }

    static class Cat extends Animal {
        @Override String sound() { return "Meow"; }
    }

    public static void main(String[] args) {
        Animal a = new Dog();  // widening (upcasting) — no cast needed

        // Narrowing (downcasting) — needs explicit cast
        Dog d = (Dog) a;       // safe: a IS a Dog
        System.out.println(d.fetch());

        // ClassCastException at runtime
        Animal c = new Cat();
        try {
            Dog d2 = (Dog) c;   // Cat is not a Dog!
        } catch (ClassCastException e) {
            System.out.println("Cast failed: " + e.getMessage());
        }

        // Safe pattern: instanceof before cast
        Animal[] animals = { new Dog(), new Cat(), new Dog() };
        for (Animal animal : animals) {
            if (animal instanceof Dog dog) {  // pattern variable (Java 16+)
                System.out.println("Dog says: " + dog.fetch());
            }
        }
    }
}

// Example 3: Autoboxing and Unboxing
// File: AutoboxingDemo.java
import java.util.ArrayList;
import java.util.List;

public class AutoboxingDemo {
    public static void main(String[] args) {
        // Autoboxing: int → Integer
        Integer boxed = 42;              // Integer.valueOf(42)
        int unboxed = boxed;             // boxed.intValue()

        // Caching: -128 to 127
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b);      // true (cached)

        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d);      // false (different objects)
        System.out.println(c.equals(d)); // true (same value)

        // Null unboxing → NullPointerException
        Integer n = null;
        try {
            int x = n;  // n.intValue() → NPE
        } catch (NullPointerException e) {
            System.out.println("Unboxed null! " + e.getMessage());
        }

        // Mixed arithmetic triggers unboxing
        Integer sum = 10;
        sum = sum + 5;  // unboxed to int, added, re-boxed
        System.out.println("sum: " + sum);

        // Collections require reference types
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);  // autoboxed
        numbers.add(2);
        int total = 0;
        for (int num : numbers) {  // autounboxed in each iteration
            total += num;
        }
        System.out.println("total: " + total);
    }
}

// Example 4: Numeric Promotion
// File: NumericPromotion.java
public class NumericPromotion {
    public static void main(String[] args) {
        // byte + byte = int (promotion!)
        byte x = 10;
        byte y = 20;
        // byte result = x + y;  // COMPILE ERROR
        int result = x + y;      // OK: both promoted to int
        byte cast = (byte)(x + y); // explicit cast back

        // char arithmetic
        char c1 = 'A';  // 65
        char c2 = 'B';  // 66
        // char sum = c1 + c2;  // COMPILE ERROR: result is int
        int charSum = c1 + c2;    // 131
        System.out.println("A+B = " + charSum);

        // Mixed int and long
        int i = Integer.MAX_VALUE;
        long l = i + 1L;    // i promoted to long first
        System.out.println("int max + 1L = " + l);  // not overflow

        // int + int overflow (no long promotion)
        long bad = i + 1;   // i+1 computed as int (overflow!), then stored to long
        System.out.println("int overflow + long store = " + bad);  // -2147483648

        // float vs double precision
        float f = 1.0f / 3.0f;
        double d = 1.0 / 3.0;
        System.out.printf("float:  %.20f%n", (double) f);
        System.out.printf("double: %.20f%n", d);
    }
}

// Example 5: Pattern Matching — instanceof and switch (Java 21)
// File: PatternCasting.java
public class PatternCasting {

    sealed interface Expr permits Num, Add, Mul {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}
    record Mul(Expr left, Expr right) implements Expr {}

    static int eval(Expr expr) {
        return switch (expr) {
            case Num(int v)             -> v;
            case Add(Expr l, Expr r)    -> eval(l) + eval(r);
            case Mul(Expr l, Expr r)    -> eval(l) * eval(r);
        };
    }

    static String format(Expr expr) {
        return switch (expr) {
            case Num(int v)             -> String.valueOf(v);
            case Add(Expr l, Expr r)    -> "(" + format(l) + " + " + format(r) + ")";
            case Mul(Expr l, Expr r)    -> "(" + format(l) + " * " + format(r) + ")";
        };
    }

    public static void main(String[] args) {
        // (2 + 3) * 4
        Expr expr = new Mul(new Add(new Num(2), new Num(3)), new Num(4));
        System.out.println(format(expr) + " = " + eval(expr));  // (2 + 3) * 4 = 20
    }
}