Type Casting in Java Explained — Widening, Narrowing and ClassCastException

public class WideningCastingDemo {
    public static void main(String[] args) {

        // Start with a small integer value — byte can hold -128 to 127
        byte playerLevel = 42;

        // Java automatically widens byte → short → int → long → float → double
        short levelAsShort   = playerLevel;  // byte   → short  (automatic)
        int   levelAsInt     = playerLevel;  // byte   → int    (automatic)
        long  levelAsLong    = playerLevel;  // byte   → long   (automatic)
        float levelAsFloat   = playerLevel;  // byte   → float  (automatic)
        double levelAsDouble = playerLevel;  // byte   → double (automatic)

        System.out.println("Original byte value  : " + playerLevel);
        System.out.println("Widened to short     : " + levelAsShort);
        System.out.println("Widened to int       : " + levelAsInt);
        System.out.println("Widened to long      : " + levelAsLong);
        System.out.println("Widened to float     : " + levelAsFloat);
        System.out.println("Widened to double    : " + levelAsDouble);

        // A very common real-world example: mixing int arithmetic with double
        int   totalPoints  = 950;
        int   maxPoints    = 1000;
        // Without widening, 950 / 1000 in integer math = 0 (integer division)
        // Java widens totalPoints to double BEFORE dividing because percentageScore is double
        double percentageScore = (double) totalPoints / maxPoints * 100;
        System.out.println("\nScore percentage     : " + percentageScore + "%");
    }
}

public class NarrowingCastingDemo {
    public static void main(String[] args) {

        // --- Example 1: double to int ---
        // Imagine a physics simulation where position is calculated as a double
        // but we need an integer pixel coordinate to draw on screen
        double precisePosition = 47.89;

        // Without explicit cast, this line won't compile — Java forces you to be intentional
        int pixelPosition = (int) precisePosition;  // truncates: 47.89 → 47 (NOT rounded).

        System.out.println("Precise position (double) : " + precisePosition);
        System.out.println("Pixel position   (int)    : " + pixelPosition);
        System.out.println("Note: .89 was silently dropped, not rounded up!");

        // --- Example 2: double to int — rounding trap ---
        double almostTen = 9.9999;
        int truncated = (int) almostTen;  // still becomes 9, NOT 10
        System.out.println("\n9.9999 cast to int = " + truncated + "  (NOT 10!)");

        // If you actually WANT rounding, use Math.round() BEFORE casting
        int rounded = (int) Math.round(almostTen);  // Math.round returns long, we cast to int
        System.out.println("Math.round(9.9999) cast to int = " + rounded + "  (correct)");

        // --- Example 3: int to byte — the surprising bit-drop behaviour ---
        int largeNumber = 300;  // 300 in binary: 0000 0001 0010 1100
        // byte only has 8 bits, so it keeps only the rightmost 8 bits: 0010 1100 = 44
        byte narrowedToByte = (byte) largeNumber;  // 300 becomes 44 — data is destroyed

        System.out.println("\nOriginal int value       : " + largeNumber);
        System.out.println("Cast to byte             : " + narrowedToByte);
        System.out.println("(300 lost its upper bits — only lowest 8 bits survive)");

        // --- Example 4: Safe narrowing with a range check ---
        int userAge = 25;
        if (userAge >= Byte.MIN_VALUE && userAge <= Byte.MAX_VALUE) {
            byte ageAsByte = (byte) userAge;  // safe because 25 fits in -128 to 127
            System.out.println("\nAge safely stored as byte: " + ageAsByte);
        } else {
            System.out.println("\nValue too large for byte — skipping cast");
        }
    }
}

// Base class — the general category
class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    void makeSound() {
        System.out.println(name + " makes a generic animal sound");
    }
}

// Subclass — a specific type of Animal
class Dog extends Animal {
    String breed;

    Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }

    @Override
    void makeSound() {
        System.out.println(name + " barks!");
    }

    void fetch() {
        System.out.println(name + " the " + breed + " fetches the ball!");
    }
}

// Another subclass
class Cat extends Animal {
    Cat(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " meows!");
    }
}

public class ObjectCastingDemo {
    public static void main(String[] args) {

        // --- UPCASTING (implicit, always safe) ---
        // A Dog IS-AN Animal, so this assignment is automatic
        Dog myDog = new Dog("Rex", "Labrador");
        Animal animalRef = myDog;  // upcast: Dog → Animal, no syntax needed

        System.out.println("=== Upcasting ===");
        animalRef.makeSound();  // calls Dog's overridden version — polymorphism in action
        // animalRef.fetch();   // COMPILE ERROR: Animal type doesn't know about fetch()

        // --- SAFE DOWNCASTING with instanceof ---
        System.out.println("\n=== Safe Downcasting ===");
        if (animalRef instanceof Dog) {
            // We've confirmed it IS a Dog, so the cast is guaranteed to succeed
            Dog recoveredDog = (Dog) animalRef;  // downcast: Animal → Dog
            recoveredDog.fetch();  // now we can call Dog-specific methods
            System.out.println("Breed: " + recoveredDog.breed);
        }

        // --- UNSAFE DOWNCASTING — what NOT to do ---
        System.out.println("\n=== Unsafe Downcasting (caught gracefully) ===");
        Animal catRef = new Cat("Whiskers");  // catRef holds a Cat, not a Dog
        if (catRef instanceof Dog) {
            Dog wrongCast = (Dog) catRef;  // this block never runs — instanceof guards us
        } else {
            System.out.println(catRef.name + " is not a Dog — cast skipped safely");
        }

        // --- What happens WITHOUT the instanceof check ---
        System.out.println("\n=== ClassCastException Demo ===");
        try {
            Dog illegalCast = (Dog) catRef;  // Cat cannot be cast to Dog — BOOM at runtime
        } catch (ClassCastException e) {
            // The JVM tells you exactly what went wrong
            System.out.println("Caught: " + e.getMessage());
        }

        // --- Java 16+ Pattern Matching instanceof (cleaner syntax) ---
        System.out.println("\n=== Pattern Matching instanceof (Java 16+) ===");
        Animal anotherDog = new Dog("Buddy", "Poodle");
        // Checks AND casts in one line — no repeated type name
        if (anotherDog instanceof Dog patternDog) {
            patternDog.fetch();  // patternDog is already the Dog type — no separate cast line
        }
    }
}