Narrowing Casting

// Narrowing hierarchy (right to left requires explicit cast):
// double → float → long → int → short → byte
//                          ↓
//                         char

// Syntax: (targetType) expression
double d = 9.99;
float  f = (float)  d;   // double → float
long   l = (long)   d;   // double → long
int    i = (int)    d;   // double → int
short  s = (short)  d;   // double → short
byte   b = (byte)   d;   // double → byte

// You can skip steps — narrowing works across multiple levels:
double big = 1234.99;
byte small = (byte) big;  // double directly to byte — valid (but very lossy)

// Without the cast — compile error:
double x = 3.14;
int y = x;         // COMPILE ERROR: possible lossy conversion from double to int
int z = (int) x;   // correct — explicit cast, z = 3

// Truncation — NOT rounding:
double d1 = 9.1;
double d2 = 9.5;
double d3 = 9.9;
double d4 = -9.9;

System.out.println((int) d1);   // 9  — truncated
System.out.println((int) d2);   // 9  — truncated, NOT rounded to 10
System.out.println((int) d3);   // 9  — truncated, NOT rounded to 10
System.out.println((int) d4);   // -9 — truncated toward zero, NOT -10

// If you need rounding, use Math.round() before casting:
System.out.println(Math.round(9.5));    // 10 — rounds to nearest
System.out.println(Math.round(9.4));    // 9
System.out.println(Math.round(-9.5));   // -9 — rounds toward positive infinity
System.out.println((int) Math.round(9.9));  // 10 — round then cast to int

// Math.floor and Math.ceil for directed rounding:
System.out.println((int) Math.floor(9.9));  // 9  — round down
System.out.println((int) Math.ceil(9.1));   // 10 — round up

// float to int — same truncation behavior:
float f = 99.99f;
int fromFloat = (int) f;
System.out.println(fromFloat);  // 99 — decimal truncated

// int to byte — byte range is -128 to 127:
int a = 127;
int b = 128;
int c = 255;
int d = 256;
int e = 300;

System.out.println((byte) a);   //  127 — fits exactly
System.out.println((byte) b);   // -128 — just outside range, wraps to minimum
System.out.println((byte) c);   //   -1 — wraps around
System.out.println((byte) d);   //    0 — 256 wraps to 0
System.out.println((byte) e);   //   44 — 300 - 256 = 44

// How wrapping works — only the lowest 8 bits are kept for byte:
// 300 in binary: 0000_0001_0010_1100
// Keep 8 bits:        0010_1100  = 44

// int to short — short range is -32768 to 32767:
int big = 40000;
System.out.println((short) big);   // -25536 — wrapped

// long to int — high 32 bits are discarded:
long huge = 10_000_000_000L;       // 10 billion
System.out.println((int) huge);    // 1410065408 — corrupted

long safe = 2_000_000_000L;        // 2 billion — within int range
System.out.println((int) safe);    // 2000000000 — correct

// Checking before casting to avoid overflow:
long value = 10_000_000_000L;
if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) {
    int intValue = (int) value;   // safe
} else {
    System.out.println("Value too large for int");
}

// Math.toIntExact() — throws ArithmeticException instead of silently overflowing:
int exact = Math.toIntExact(2_000_000_000L);   // 2000000000 — fine
int overflow = Math.toIntExact(10_000_000_000L); // throws ArithmeticException

// double to float — precision loss:
double d1 = 3.141592653589793;   // 15-16 significant digits
float  f1 = (float) d1;
System.out.println(d1);  // 3.141592653589793
System.out.println(f1);  // 3.1415927 — rounded to 7 significant digits

double d2 = 123_456_789.987654321;
float  f2 = (float) d2;
System.out.println(d2);  // 1.2345678998765432E8
System.out.println(f2);  // 1.23456792E8 — last digits differ

// Special values survive narrowing:
double inf = Double.POSITIVE_INFINITY;
float  fInf = (float) inf;
System.out.println(fInf);  // Infinity — preserved

double nan = Double.NaN;
float  fNan = (float) nan;
System.out.println(fNan);  // NaN — preserved

// Very small double values may underflow to 0.0f:
double tiny = Double.MIN_VALUE;   // ~5E-324
float  fTiny = (float) tiny;
System.out.println(fTiny);        // 0.0 — underflows to zero

// Very large double values may overflow to Infinity in float:
double huge = Double.MAX_VALUE;   // ~1.8E308
float  fHuge = (float) huge;
System.out.println(fHuge);        // Infinity — overflows float's max (~3.4E38)

// int to char — keeps lower 16 bits:
int code = 65;
char letter = (char) code;
System.out.println(letter);   // 'A'

int bigCode = 70000;          // exceeds char range (0-65535)
char wrapped = (char) bigCode;
System.out.println((int) wrapped);  // 4464 — 70000 % 65536

// Negative int to char — wraps since char is unsigned:
int negative = -1;
char fromNeg = (char) negative;
System.out.println((int) fromNeg);  // 65535 — -1 interpreted as unsigned max

int neg2 = -65;
char fromNeg2 = (char) neg2;
System.out.println((int) fromNeg2);  // 65471

// char to byte and short — requires explicit cast:
char c = 'A';                // 65
byte b = (byte) c;           // 65 — fits fine
System.out.println(b);       // 65

char highChar = '\u0100';   // 256 — outside byte range
byte narrowed = (byte) highChar;
System.out.println(narrowed);  // 0 — 256 wraps to 0 in byte

// char to short — char is unsigned, short is signed:
char big = '\uFF00';        // 65280 — valid char, but exceeds short max
short s = (short) big;
System.out.println(s);       // -256 — sign bit interpreted differently

class Animal { void speak() { System.out.println("..."); } }
class Dog extends Animal {
    void speak() { System.out.println("Woof!"); }
    void fetch() { System.out.println("Fetching!"); }
}
class Cat extends Animal {
    void speak() { System.out.println("Meow!"); }
}

// Upcasting first (widening — automatic):
Animal a = new Dog();   // a holds a Dog, typed as Animal

// Downcasting (narrowing — explicit cast required):
Dog d = (Dog) a;        // safe — a actually IS a Dog
d.fetch();              // works fine

// Wrong downcast — compiles but throws at runtime:
Animal a2 = new Cat();
Dog d2 = (Dog) a2;      // compiles fine
                        // throws ClassCastException at runtime:
                        // class Cat cannot be cast to class Dog

// Always guard with instanceof before downcasting:
Animal unknown = getAnimal();

// Traditional approach:
if (unknown instanceof Dog) {
    Dog safeDog = (Dog) unknown;
    safeDog.fetch();
}

// Pattern matching (Java 16+) — cleaner, no separate cast needed:
if (unknown instanceof Dog safeDog) {
    safeDog.fetch();   // safeDog is already typed as Dog
}

// Switch pattern matching (Java 21+):
switch (unknown) {
    case Dog dog   -> dog.fetch();
    case Cat cat   -> cat.speak();
    case Animal a3 -> a3.speak();
}

// ── Pattern 1: Range check before narrowing int/long ────────────
long value = getLongValue();
if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
    throw new ArithmeticException("Value out of byte range: " + value);
}
byte safe = (byte) value;

// ── Pattern 2: Math.toIntExact() for long → int ──────────────────
// Throws ArithmeticException on overflow instead of silently wrapping:
long longVal = 50_000L;
int intVal = Math.toIntExact(longVal);   // safe if within int range

// ── Pattern 3: Round before casting floating point ───────────────
double d = 9.7;
int truncated = (int) d;                  // 9  — is this what you want?
int rounded   = (int) Math.round(d);      // 10 — probably what you want
int floored   = (int) Math.floor(d);      // 9  — always rounds down
int ceiled    = (int) Math.ceil(d);       // 10 — always rounds up

// ── Pattern 4: instanceof before downcasting objects ────────────
if (animal instanceof Dog dog) {
    dog.fetch();   // Java 16+ pattern matching — safest approach
}

// ── Pattern 5: BigDecimal for precise decimal narrowing ──────────
import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal bd = new BigDecimal("9.876");
int asInt = bd.setScale(0, RoundingMode.HALF_UP).intValue();  // 10
double asDouble = bd.doubleValue();  // 9.876

// ── Pattern 6: Clamp to target range before casting ──────────────
int original = 300;
byte clamped = (byte) Math.max(Byte.MIN_VALUE,
                               Math.min(Byte.MAX_VALUE, original));
// clamped = 127 — saturates at max instead of wrapping

// ── Widening ─────────────────────────────────────────────────────
int i = 100;
double d = i;        // automatic — no syntax needed
long l = i;          // automatic
float f = i;         // automatic

// Safe: every int value fits in double, long, float
// No data loss for int → long or int → double
// Possible precision loss for large int → float (see widening tag)

// ── Narrowing ────────────────────────────────────────────────────
double pi = 3.14159;
int fromPi = (int) pi;       // explicit cast required: (int)
// fromPi = 3 — decimal truncated silently

long big = 10_000_000_000L;
int fromBig = (int) big;     // explicit cast required: (int)
// fromBig = 1410065408 — silently overflowed

// Summary table:
//
// Direction          Syntax          Safe?     Data loss?
// ─────────────────────────────────────────────────────────
// small → large      automatic       always    never*
// large → small      (type) value    never     possible
//
// * except long/int → float precision loss (see widening tag)