Widening Casting

// Widening hierarchy:
// byte → short → int → long → float → double
//                ↑
//              char (char widens to int and beyond, but NOT to byte or short)

// Every step is valid:
byte   byteVal   = 10;
short  shortVal  = byteVal;   // byte  → short
int    intVal    = shortVal;  // short → int
long   longVal   = intVal;    // int   → long
float  floatVal  = longVal;   // long  → float
double doubleVal = floatVal;  // float → double

// You can skip steps — widening works across multiple levels:
byte b = 42;
double d = b;    // byte directly to double — valid
long l = b;      // byte directly to long — valid

// char widens to int and beyond:
char c = 'A';          // 65
int charToInt = c;     // 65
long charToLong = c;   // 65L
float charToFloat = c; // 65.0f
double charToDouble = c; // 65.0

// char does NOT widen to byte or short (even though char is 16-bit):
byte charToByte = c;   // COMPILE ERROR — requires explicit cast
short charToShort = c; // COMPILE ERROR — requires explicit cast

// Direct assignment — widening is automatic:
int i = 1000;
long l = i;        // int widened to long — no cast needed
double d = i;      // int widened to double — no cast needed
float f = i;       // int widened to float — no cast needed

// Works across multiple variable uses:
byte b = 100;
short s = b;       // byte → short
int total = s + b; // both widen to int for arithmetic (see type promotion)

// Widening with literals — compiler handles small literal values:
byte bLiteral = 42;    // 42 is an int literal, but compiler knows it fits
short sLiteral = 1000; // same — 1000 fits in short

// But widening doesn't apply to explicit large literals:
byte overflow = 200;   // COMPILE ERROR — 200 doesn't fit in byte (-128 to 127)
short bigShort = 40000; // COMPILE ERROR — 40000 exceeds short max (32767)

// Final variables — compiler can widen if value is known at compile time:
final int CONSTANT = 50;
byte b2 = CONSTANT;    // valid — compiler knows 50 fits in byte

// Method accepts double, called with int — widening happens:
void printArea(double radius) {
    System.out.println(Math.PI * radius * radius);
}

printArea(5);      // int 5 widened to double 5.0 automatically
printArea(5L);     // long widened to double
printArea(5.0f);   // float widened to double

// Overloaded method resolution — Java picks the widest applicable method:
void process(int x)    { System.out.println("int: " + x); }
void process(long x)   { System.out.println("long: " + x); }
void process(double x) { System.out.println("double: " + x); }

process(42);      // calls process(int) — exact match wins over widening
process(42L);     // calls process(long) — exact match
process(42.0);    // calls process(double) — exact match

// When there's no exact match, Java widens to the nearest applicable type:
void show(long x)   { System.out.println("long: " + x); }
void show(double x) { System.out.println("double: " + x); }

show(42);      // calls show(long) — int widens to long (nearest widening)
show(42.0f);   // calls show(double) — float widens to double (nearest widening)

// byte and short promote to int in arithmetic:
byte a = 10;
byte b = 20;
// byte result = a + b;   // COMPILE ERROR — a + b produces int, not byte
int result = a + b;       // correct — int holds the promoted result
byte back = (byte)(a + b); // if you need byte, explicit cast required

// The promotion rules:
// 1. If either operand is double  → both promoted to double
// 2. If either operand is float   → both promoted to float
// 3. If either operand is long    → both promoted to long
// 4. Otherwise                   → both promoted to int

int i = 100;
long l = 200L;
long sum = i + l;      // int promoted to long — result is long

int i2 = 100;
double d = 3.14;
double mixed = i2 + d; // int promoted to double — result is double

// Common confusion — integer division before widening:
int x = 7, y = 2;
double wrong = x / y;          // 3.0 — division is int first, THEN widened
double right = (double) x / y; // 3.5 — cast x to double BEFORE division

// String concatenation — any type widens to String with +:
int count = 42;
String s = "Count: " + count;  // int → String via widening to Object chain

// long to float — precision loss is possible:
long precise = 123_456_789_012_345L;
float f = precise;   // widening — but float only has ~7 significant digits
System.out.println(precise);  // 123456789012345
System.out.println(f);        // 1.23456794E14 — last digits are wrong

// long to double — better, but still possible for very large longs:
long big = 9_999_999_999_999_999L;
double d = big;
System.out.println(big);   // 9999999999999999
System.out.println(d);     // 1.0E16 — precision lost in last digits

// int to float — precision loss possible for large ints:
int largeInt = 123_456_789;
float fInt = largeInt;
System.out.println(largeInt);  // 123456789
System.out.println(fInt);      // 1.23456792E8 — last digit differs

// int to double — safe (double has 52-bit mantissa, int is 32-bit):
int safeInt = 123_456_789;
double safeDouble = safeInt;
System.out.println(safeDouble);  // 1.23456789E8 — exact

// Summary of precision safety:
// byte/short/int → double  : SAFE (always exact)
// byte/short/int → float   : UNSAFE for large int values
// long → double            : UNSAFE for very large long values
// long → float             : UNSAFE for most non-trivial long values

class Animal {
    void speak() { System.out.println("..."); }
}

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

// Upcasting — widening reference type (automatic, no cast syntax):
Dog dog = new Dog();
Animal animal = dog;    // Dog reference widened to Animal — automatic

// Polymorphism — the object's actual type still determines behavior:
animal.speak();         // "Woof!" — Dog's speak() is called, not Animal's
// animal.fetch();      // COMPILE ERROR — Animal type doesn't expose fetch()

// Widening in collections — storing subtypes in a supertype collection:
List<Animal> animals = new ArrayList<>();
animals.add(new Dog());    // Dog widened to Animal — automatic
animals.add(new Cat());    // Cat widened to Animal — automatic

// Widening to Object — every class widens to Object:
Object obj = "Hello";      // String widened to Object
Object obj2 = 42;          // Integer (autoboxed) widened to Object
Object obj3 = new Dog();   // Dog widened to Object

// Interface widening — assigning to an interface the class implements:
interface Printable { void print(); }
class Report implements Printable {
    public void print() { System.out.println("Report"); }
}

Printable p = new Report();  // Report widened to Printable — automatic
p.print();                   // "Report"