☕ Java Type Casting — Complete Deep Revision Guide

📖 Type Casting Kya Hai?

Ek data type ki value ko doosre data type mein convert karna.

int a = 100;
double b = a;  ← int ko double mein daal diya = TYPE CASTING

Memory mein sizes:

byte(1) → short(2) → int(4) → long(8) → float(4) → double(8)
↑ CHOTA BADA ↑

✅ Widening (Implicit)

Chote se Bade mein
Automatic / Safe
byte → short → int → long → float → double

❌ Narrowing (Explicit)

Bade se Chote mein
Manual / Risky
Data loss ho sakta hai

🔵 Topic 1: Widening (Implicit) Type Casting

Deep Explanation: Widening matlab chote container ki cheez bade container mein daalna — automatically hota hai, kuch likhna nahi padta.

🥛 Glass (int) → 🪣 Bucket (double) → automatically fit ho jaata hai

int x = 100;
double y = x;  ← compiler khud karta hai
               Java sochta hai: "int → double safe hai, karo"

✅ Safe — Data loss NAHI hoga (mostly)
✅ Automatic — Implicit kehte hain isliye

byte(8bit) → short(16bit) → int(32bit) → long(64bit) → float(32bit) → double(64bit)

📁 Widening1.java

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

        byte   b = 10;
        short  s = b;   // byte → short  (automatic)
        int    i = s;   // short → int   (automatic)
        long   l = i;   // int → long    (automatic)
        float  f = l;   // long → float  (automatic)
        double d = f;   // float → double (automatic)

        System.out.println("byte   value: " + b);
        System.out.println("short  value: " + s);
        System.out.println("int    value: " + i);
        System.out.println("long   value: " + l);
        System.out.println("float  value: " + f);
        System.out.println("double value: " + d);
    }
}

▶ OUTPUT

byte value: 10
short value: 10
int value: 10
long value: 10
float value: 10.0
double value: 10.0

💡 Short Explain: Ek hi value 10 ko har baar bade type mein daala — koi casting manually nahi likhi, Java ne khud kiya.

📁 Widening2.java

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

        int    marks      = 95;
        double percentage = marks; // int → double automatic

        System.out.println("Marks (int):         " + marks);
        System.out.println("Percentage (double): " + percentage);

        int a    = 10;
        int bVal = 3;
        double result  = a / bVal;           // ❌ pehle int/int = 3, phir 3.0
        double result2 = (double) a / bVal;  // ✅ sahi tarika

        System.out.println("Wrong division:   " + result);   // 3.0
        System.out.println("Correct division: " + result2);  // 3.3333
    }
}

▶ OUTPUT

Marks (int): 95
Percentage (double): 95.0
Wrong division: 3.0
Correct division: 3.3333333333333335

💡 Division mein dhyan rakho — int/int pehle integer division hoti hai phir widen hota hai. Sahi result ke liye pehle cast karo.

📁 Widening3.java

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

        // char → int widening (char ka ASCII value milta hai)
        char ch    = 'A';
        int  ascii = ch;   // char → int automatic, 'A' ka ASCII = 65

        System.out.println("char value:  " + ch);
        System.out.println("int  value:  " + ascii);   // 65

        char ch2    = 'a';
        int  ascii2 = ch2;
        System.out.println("char value:  " + ch2);
        System.out.println("int  value:  " + ascii2);  // 97

        // char → double bhi possible
        double d = ch;
        System.out.println("double value: " + d);       // 65.0
    }
}

▶ OUTPUT

char value: A
int value: 65
char value: a
int value: 97
double value: 65.0

💡 char se int mein widening hone par ASCII value milti hai. 'A' = 65, 'a' = 97, '0' = 48.

📁 Widening4.java

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

        int price = 500;
        printPrice(price);        // int diya, double maanga → auto widening

        long bigNumber = 1234567890L;
        printPrice(bigNumber);    // long diya → auto widening
    }

    // method double leta hai
    static void printPrice(double amount) {
        System.out.println("Price: Rs." + amount);
    }
}

▶ OUTPUT

Price: Rs.500.0
Price: Rs.1.23456789E9

💡 Method ko double chahiye tha, humne int diya — Java ne automatically widen kar diya. Yahi real-world widening use case hai.

📁 Widening5.java

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

        // Widening mein data loss NAHI hota (mostly)
        int  x = 2147483647;   // int ka max value
        long y = x;             // safe - long mein fit ho jaayega

        System.out.println("int  max: " + x);
        System.out.println("long val: " + y);

        // int → float mein THODA precision loss ho sakta hai
        int   bigInt = 123456789;
        float f      = bigInt;   // widening but float mein precision kam hai

        System.out.println("int   val: " + bigInt);
        System.out.println("float val: " + f);    // thoda different!
    }
}

▶ OUTPUT

int max: 2147483647
long val: 2147483647
int val: 123456789
float val: 1.23456792E8

💡 int → long mein data loss zero. But int → float mein float ki precision limit hoti hai toh thoda change ho sakta hai.

🔴 Topic 2: Narrowing (Explicit) Type Casting

Deep Explanation: Narrowing matlab bade container ki cheez chote container mein daalna — manually karna padta hai.

🪣 Bucket (double) → 🥛 Glass (int) → manually karna padta hai, glass overflow ho sakta hai!

double d = 9.99;
int    i = (int) d;  ← (int) likhna padta hai explicitly

⚠️ Data Loss: double 9.99 → int 9 (.99 chala gaya! truncation)
⚠️ Overflow: int 300 → byte ? (byte max 127 hai, 300 fit nahi hoga!)

📁 Narrowing1.java

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

        double d = 9.99;
        int    i = (int) d;   // ← explicit cast zaroori hai
        // decimal part CHALA JAATA hai (truncation, rounding nahi!)

        System.out.println("double value: " + d);  // 9.99
        System.out.println("int    value: " + i);  // 9 (not 10!)

        double d2 = 3.1;
        int    i2 = (int) d2;
        System.out.println("double value: " + d2); // 3.1
        System.out.println("int    value: " + i2); // 3
    }
}

▶ OUTPUT

double value: 9.99
int value: 9
double value: 3.1
int value: 3

💡 9.99 → 9 — decimal part cut ho gaya, rounding NAHI hoti, sirf truncation (kaat do) hoti hai. Yeh data loss hai.

📁 Narrowing2.java

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

        // int → byte: byte ka range -128 to 127
        int  i1 = 100;
        byte b1 = (byte) i1;   // 100 fits in byte
        System.out.println("int 100 → byte: " + b1);   // 100

        int  i2 = 130;
        byte b2 = (byte) i2;   // 130 > 127, overflow hoga!
        System.out.println("int 130 → byte: " + b2);   // -126 (unexpected!)

        int  i3 = 256;
        byte b3 = (byte) i3;
        System.out.println("int 256 → byte: " + b3);   // 0 (256 % 256 = 0)

        int  i4 = 257;
        byte b4 = (byte) i4;
        System.out.println("int 257 → byte: " + b4);   // 1
    }
}

▶ OUTPUT

int 100 → byte: 100
int 130 → byte: -126
int 256 → byte: 0
int 257 → byte: 1

💡 130 → -126 — yeh overflow hai! Jab value range se bahar ho toh unexpected result aata hai. Isliye narrowing "risky" hai.

📁 Narrowing3.java

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

        // long → int → short → byte chain
        long  l = 1000L;
        int   i = (int)   l;   // long → int
        short s = (short) i;   // int → short
        byte  b = (byte)  s;   // short → byte

        System.out.println("long  value: " + l);  // 1000
        System.out.println("int   value: " + i);  // 1000
        System.out.println("short value: " + s);  // 1000
        System.out.println("byte  value: " + b);  // -24 (overflow!)

        // float → int
        float f         = 45.7f;
        int   fromFloat = (int) f;
        System.out.println("float " + f + " → int: " + fromFloat); // 45
    }
}

▶ OUTPUT

long value: 1000
int value: 1000
short value: 1000
byte value: -24
float 45.7 → int: 45

💡 1000 byte mein fit nahi hota (max 127), toh overflow. Narrowing chain mein har step pe loss possible hai.

📁 Narrowing4.java

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

        // int → char (ASCII se character)
        int  ascii = 65;
        char ch    = (char) ascii;   // 65 → 'A'
        System.out.println("int 65 → char: " + ch);   // A

        int  ascii2 = 97;
        char ch2    = (char) ascii2;  // 97 → 'a'
        System.out.println("int 97 → char: " + ch2);  // a

        // double → int → char chain
        double d = 66.9;
        int    i = (int)  d;          // 66.9 → 66
        char   c = (char) i;          // 66 → 'B'
        System.out.println("double 66.9 → int: " + i + " → char: " + c);
    }
}

▶ OUTPUT

int 65 → char: A
int 97 → char: a
double 66.9 → int: 66 → char: B

💡 int → char se ASCII number se character milta hai. Yeh narrowing ka ek useful case hai — ASCII table ke saath kaam karna.

📁 Narrowing5.java

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

        // Real world example - temperature convert
        double tempCelsius = 36.6;
        int    tempRounded = (int) tempCelsius;   // decimal cut
        System.out.println("Exact Temp:   " + tempCelsius + "°C");
        System.out.println("Rounded Temp: " + tempRounded + "°C");

        // Price calculation
        double totalBill = 1599.99;
        int    billInt   = (int) totalBill;
        System.out.println("Exact Bill: Rs." + totalBill);
        System.out.println("Truncated:  Rs." + billInt);

        // Safe narrowing - check karo pehle
        double safeVal = 50.5;
        if (safeVal >= Byte.MIN_VALUE && safeVal <= Byte.MAX_VALUE) {
            byte safeByte = (byte) safeVal;
            System.out.println("Safe cast: " + safeByte);
        } else {
            System.out.println("Value out of byte range! Cannot cast safely.");
        }
    }
}

▶ OUTPUT

Exact Temp: 36.6°C
Rounded Temp: 36°C
Exact Bill: Rs.1599.99
Truncated: Rs.1599
Safe cast: 50

💡 Real use case — temperature ya price ko int mein convert karna. Safe narrowing ke liye pehle range check karo.

🟡 Topic 3: char, byte, short ke beech casting

Special Rule — Bahut log miss karte hain! ⚠️

❌ byte  → char  : implicit NAHI hoga (compile error)
❌ char  → byte  : implicit NAHI hoga (compile error)
❌ short → char  : implicit NAHI hoga (compile error)
❌ char  → short : implicit NAHI hoga (compile error)

Kyun nahi hota?

byte  → signed   (-128 to 127)
short → signed   (-32768 to 32767)
char  → unsigned (0 to 65535)  ← DIFFERENT! negative nahi hota

Signed aur Unsigned ke beech automatic conversion UNSAFE hai — isliye Java ne explicitly likhna zaroori kiya.

// Fix:
byte b = 65;
char c = (char) b;  // ✅ explicit cast likhna padega

📁 CharByteCast1.java

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

        // byte → char: explicit cast zaroori
        byte b = 65;
        // char c = b;        // ❌ Compile Error!
        char c = (char) b;    // ✅ explicit cast
        System.out.println("byte 65 → char: " + c);   // A

        // char → byte: explicit cast zaroori
        char ch   = 'Z';
        // byte bVal = ch;    // ❌ Compile Error!
        byte bVal = (byte) ch;  // ✅ explicit cast
        System.out.println("char Z → byte: " + bVal);  // 90
    }
}

▶ OUTPUT

byte 65 → char: A
char Z → byte: 90

💡 byte aur char same size ke hain (almost) but different signs — byte negative ho sakta, char nahi. Isliye explicit cast must hai.

📁 CharByteCast2.java

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

        // short → char: explicit zaroori
        short s = 72;
        // char c = s;        // ❌ Compile Error!
        char  c = (char) s;    // ✅
        System.out.println("short 72 → char: " + c);   // H

        // char → short: explicit zaroori
        char  ch   = 'M';
        // short sVal = ch;   // ❌ Compile Error!
        short sVal = (short) ch;  // ✅
        System.out.println("char M → short: " + sVal);  // 77
    }
}

▶ OUTPUT

short 72 → char: H
char M → short: 77

💡 short signed hai, char unsigned — dono 16-bit hain par different range. Isliye implicit casting blocked hai Java mein.

📁 CharByteCast3.java

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

        // char range: 0 to 65535
        char maxChar   = '\uFFFF';  // max char value
        int  charAsInt = maxChar;
        System.out.println("Max char as int: " + charAsInt);  // 65535

        // Negative byte → char kya hoga?
        byte negByte   = -1;
        char fromNeg   = (char) negByte;  // explicit cast
        int  result    = fromNeg;
        System.out.println("byte -1 → char → int: " + result);  // 65535!
        // -1 ka binary = 11111111 11111111 → char mein 65535 ban gaya
    }
}

▶ OUTPUT

Max char as int: 65535
byte -1 → char → int: 65535

💡 Yahi problem hai! byte -1 ko char mein daalo toh 65535 ban jaata hai — negative value ka meaning change ho gaya. Isliye implicit casting unsafe hai.

📁 CharByteCast4.java

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

        // Saare conversions int ke through safe hote hain

        // char → int → byte (do step)
        char ch = 'A';         // 65
        int  i  = ch;          // char → int : ✅ widening (OK)
        byte b  = (byte) i;   // int → byte : explicit cast
        System.out.println("char A → int: " + i + " → byte: " + b);

        // byte → int → char (do step)
        byte b2 = 66;
        int  i2 = b2;           // byte → int : ✅ widening (OK)
        char c2 = (char) i2;   // int → char : explicit cast
        System.out.println("byte 66 → int: " + i2 + " → char: " + c2);

        // Direct path:
        byte b3 = 67;
        char c3 = (char) b3;   // bhi chalega explicit se
        System.out.println("Direct byte 67 → char: " + c3);
    }
}

▶ OUTPUT

char A → int: 65 → byte: 65
byte 66 → int: 66 → char: B
Direct byte 67 → char: C

💡 Safe way — pehle int mein convert karo (widening), phir jahan chahiye cast karo. Ya direct explicit cast use karo.

🟢 Topic 4: Casting + Arithmetic Expressions

Deep Explanation: Expression mein casting bohot important hai — galat jagah cast karo toh galat answer aata hai.

// ❌ GALAT
int a = 5, b = 2;
double result = a / b;           // pehle int/int = 2, phir 2.0

// ✅ SAHI
double result = (double) a / b;  // pehle 5.0/2, phir 2.5

⚠️ Rule: Cast jo pehle hoti hai woh calculation ko affect karti hai.

📁 CastArithmetic1.java

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

        int a = 7, b = 2;

        // ❌ Wrong - int division pehle hoti hai
        double wrong = a / b;
        System.out.println("Wrong:    " + wrong);   // 3.0

        // ✅ Correct - pehle cast karo
        double correct = (double) a / b;
        System.out.println("Correct:  " + correct);  // 3.5

        // ✅ Dono cast karo
        double correct2 = (double) a / (double) b;
        System.out.println("Correct2: " + correct2); // 3.5
    }
}

▶ OUTPUT

Wrong: 3.0
Correct: 3.5
Correct2: 3.5

📁 CastArithmetic2.java

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

        // Percentage calculate karna
        int scored = 450;
        int total  = 600;

        // ❌ Wrong way
        double wrongPercent = scored / total * 100;
        System.out.println("Wrong  %: " + wrongPercent);   // 0.0

        // ✅ Correct way
        double correctPercent = (double) scored / total * 100;
        System.out.println("Correct%: " + correctPercent);  // 75.0

        // Average
        int    s1  = 80, s2 = 90, s3 = 75;
        double avg = (double)(s1 + s2 + s3) / 3;
        System.out.println("Average: " + avg);               // 81.666...
    }
}

▶ OUTPUT

Wrong %: 0.0
Correct%: 75.0
Average: 81.66666666666667

💡 Real world mein percentage/average calculate karte waqt (double) cast bhul gaye toh 0.0 ya wrong answer milega — yeh common mistake hai!

📋 Complete Revision Summary

Type	Direction	How	Risk
Widening	Chota → Bada byte→short→int→long→float→double	Automatic / Implicit	✅ Safe (mostly)
Narrowing	Bada → Chota	Manual — (type) likhna padta hai	⚠️ Data loss / Overflow
char/byte/short	Inke beech koi bhi	Explicit (type) MUST hai	⚠️ signed vs unsigned
Expression	—	(double)a/b ✅ a/b wrong ❌	⚠️ Wrong result

⚠️ Data Ranges

Type	Size	Range
byte	1 byte	-128 to 127
short	2 bytes	-32,768 to 32,767
int	4 bytes	-2.1B to 2.1B
long	8 bytes	very large
float	4 bytes	decimal (7 digits)
double	8 bytes	decimal (15 digits)
char	2 bytes	0 to 65,535 (unsigned)

⚠️ Common Errors

Error	Reason	Fix
possible lossy conversion	Bina cast ke narrowing	(type) explicitly likho
incompatible types	char↔byte/short without cast	Explicit (char) ya (byte) likho
Result 0.0 ya wrong	int/int division	(double) pehle cast karo
Overflow (-126 for 130)	Value range se bahar	Range check karo pehle

🏆 Golden Rule File name = Class name exactly! Jaise class Widening1 hai toh file Widening1.java hogi!

☕ Java Type Casting — Complete Deep Revision Guide

📖 Type Casting Kya Hai?

Ek data type ki value ko doosre data type mein convert karna.

int a = 100;
double b = a;  ← int ko double mein daal diya = TYPE CASTING

Memory mein sizes:

byte(1) → short(2) → int(4) → long(8) → float(4) → double(8)
↑ CHOTA BADA ↑

✅ Widening (Implicit)

Chote se Bade mein
Automatic / Safe
byte → short → int → long → float → double

❌ Narrowing (Explicit)

Bade se Chote mein
Manual / Risky
Data loss ho sakta hai

🔵 Topic 1: Widening (Implicit) Type Casting

Deep Explanation: Widening matlab chote container ki cheez bade container mein daalna — automatically hota hai, kuch likhna nahi padta.

🥛 Glass (int) → 🪣 Bucket (double) → automatically fit ho jaata hai

int x = 100;
double y = x;  ← compiler khud karta hai
               Java sochta hai: "int → double safe hai, karo"

✅ Safe — Data loss NAHI hoga (mostly)
✅ Automatic — Implicit kehte hain isliye

byte(8bit) → short(16bit) → int(32bit) → long(64bit) → float(32bit) → double(64bit)

📁 Widening1.java

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

        byte   b = 10;
        short  s = b;   // byte → short  (automatic)
        int    i = s;   // short → int   (automatic)
        long   l = i;   // int → long    (automatic)
        float  f = l;   // long → float  (automatic)
        double d = f;   // float → double (automatic)

        System.out.println("byte   value: " + b);
        System.out.println("short  value: " + s);
        System.out.println("int    value: " + i);
        System.out.println("long   value: " + l);
        System.out.println("float  value: " + f);
        System.out.println("double value: " + d);
    }
}

▶ OUTPUT

byte value: 10
short value: 10
int value: 10
long value: 10
float value: 10.0
double value: 10.0

💡 Short Explain: Ek hi value 10 ko har baar bade type mein daala — koi casting manually nahi likhi, Java ne khud kiya.

📁 Widening2.java

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

        int    marks      = 95;
        double percentage = marks; // int → double automatic

        System.out.println("Marks (int):         " + marks);
        System.out.println("Percentage (double): " + percentage);

        int a    = 10;
        int bVal = 3;
        double result  = a / bVal;           // ❌ pehle int/int = 3, phir 3.0
        double result2 = (double) a / bVal;  // ✅ sahi tarika

        System.out.println("Wrong division:   " + result);   // 3.0
        System.out.println("Correct division: " + result2);  // 3.3333
    }
}

▶ OUTPUT

Marks (int): 95
Percentage (double): 95.0
Wrong division: 3.0
Correct division: 3.3333333333333335

💡 Division mein dhyan rakho — int/int pehle integer division hoti hai phir widen hota hai. Sahi result ke liye pehle cast karo.

📁 Widening3.java

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

        // char → int widening (char ka ASCII value milta hai)
        char ch    = 'A';
        int  ascii = ch;   // char → int automatic, 'A' ka ASCII = 65

        System.out.println("char value:  " + ch);
        System.out.println("int  value:  " + ascii);   // 65

        char ch2    = 'a';
        int  ascii2 = ch2;
        System.out.println("char value:  " + ch2);
        System.out.println("int  value:  " + ascii2);  // 97

        // char → double bhi possible
        double d = ch;
        System.out.println("double value: " + d);       // 65.0
    }
}

▶ OUTPUT

char value: A
int value: 65
char value: a
int value: 97
double value: 65.0

💡 char se int mein widening hone par ASCII value milti hai. 'A' = 65, 'a' = 97, '0' = 48.

📁 Widening4.java

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

        int price = 500;
        printPrice(price);        // int diya, double maanga → auto widening

        long bigNumber = 1234567890L;
        printPrice(bigNumber);    // long diya → auto widening
    }

    // method double leta hai
    static void printPrice(double amount) {
        System.out.println("Price: Rs." + amount);
    }
}

▶ OUTPUT

Price: Rs.500.0
Price: Rs.1.23456789E9

💡 Method ko double chahiye tha, humne int diya — Java ne automatically widen kar diya. Yahi real-world widening use case hai.

📁 Widening5.java

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

        // Widening mein data loss NAHI hota (mostly)
        int  x = 2147483647;   // int ka max value
        long y = x;             // safe - long mein fit ho jaayega

        System.out.println("int  max: " + x);
        System.out.println("long val: " + y);

        // int → float mein THODA precision loss ho sakta hai
        int   bigInt = 123456789;
        float f      = bigInt;   // widening but float mein precision kam hai

        System.out.println("int   val: " + bigInt);
        System.out.println("float val: " + f);    // thoda different!
    }
}

▶ OUTPUT

int max: 2147483647
long val: 2147483647
int val: 123456789
float val: 1.23456792E8

💡 int → long mein data loss zero. But int → float mein float ki precision limit hoti hai toh thoda change ho sakta hai.

🔴 Topic 2: Narrowing (Explicit) Type Casting

Deep Explanation: Narrowing matlab bade container ki cheez chote container mein daalna — manually karna padta hai.

🪣 Bucket (double) → 🥛 Glass (int) → manually karna padta hai, glass overflow ho sakta hai!

double d = 9.99;
int    i = (int) d;  ← (int) likhna padta hai explicitly

⚠️ Data Loss: double 9.99 → int 9 (.99 chala gaya! truncation)
⚠️ Overflow: int 300 → byte ? (byte max 127 hai, 300 fit nahi hoga!)

📁 Narrowing1.java

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

        double d = 9.99;
        int    i = (int) d;   // ← explicit cast zaroori hai
        // decimal part CHALA JAATA hai (truncation, rounding nahi!)

        System.out.println("double value: " + d);  // 9.99
        System.out.println("int    value: " + i);  // 9 (not 10!)

        double d2 = 3.1;
        int    i2 = (int) d2;
        System.out.println("double value: " + d2); // 3.1
        System.out.println("int    value: " + i2); // 3
    }
}

▶ OUTPUT

double value: 9.99
int value: 9
double value: 3.1
int value: 3

💡 9.99 → 9 — decimal part cut ho gaya, rounding NAHI hoti, sirf truncation (kaat do) hoti hai. Yeh data loss hai.

📁 Narrowing2.java

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

        // int → byte: byte ka range -128 to 127
        int  i1 = 100;
        byte b1 = (byte) i1;   // 100 fits in byte
        System.out.println("int 100 → byte: " + b1);   // 100

        int  i2 = 130;
        byte b2 = (byte) i2;   // 130 > 127, overflow hoga!
        System.out.println("int 130 → byte: " + b2);   // -126 (unexpected!)

        int  i3 = 256;
        byte b3 = (byte) i3;
        System.out.println("int 256 → byte: " + b3);   // 0 (256 % 256 = 0)

        int  i4 = 257;
        byte b4 = (byte) i4;
        System.out.println("int 257 → byte: " + b4);   // 1
    }
}

▶ OUTPUT

int 100 → byte: 100
int 130 → byte: -126
int 256 → byte: 0
int 257 → byte: 1

💡 130 → -126 — yeh overflow hai! Jab value range se bahar ho toh unexpected result aata hai. Isliye narrowing "risky" hai.

📁 Narrowing3.java

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

        // long → int → short → byte chain
        long  l = 1000L;
        int   i = (int)   l;   // long → int
        short s = (short) i;   // int → short
        byte  b = (byte)  s;   // short → byte

        System.out.println("long  value: " + l);  // 1000
        System.out.println("int   value: " + i);  // 1000
        System.out.println("short value: " + s);  // 1000
        System.out.println("byte  value: " + b);  // -24 (overflow!)

        // float → int
        float f         = 45.7f;
        int   fromFloat = (int) f;
        System.out.println("float " + f + " → int: " + fromFloat); // 45
    }
}

▶ OUTPUT

long value: 1000
int value: 1000
short value: 1000
byte value: -24
float 45.7 → int: 45

💡 1000 byte mein fit nahi hota (max 127), toh overflow. Narrowing chain mein har step pe loss possible hai.

📁 Narrowing4.java

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

        // int → char (ASCII se character)
        int  ascii = 65;
        char ch    = (char) ascii;   // 65 → 'A'
        System.out.println("int 65 → char: " + ch);   // A

        int  ascii2 = 97;
        char ch2    = (char) ascii2;  // 97 → 'a'
        System.out.println("int 97 → char: " + ch2);  // a

        // double → int → char chain
        double d = 66.9;
        int    i = (int)  d;          // 66.9 → 66
        char   c = (char) i;          // 66 → 'B'
        System.out.println("double 66.9 → int: " + i + " → char: " + c);
    }
}

▶ OUTPUT

int 65 → char: A
int 97 → char: a
double 66.9 → int: 66 → char: B

💡 int → char se ASCII number se character milta hai. Yeh narrowing ka ek useful case hai — ASCII table ke saath kaam karna.

📁 Narrowing5.java

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

        // Real world example - temperature convert
        double tempCelsius = 36.6;
        int    tempRounded = (int) tempCelsius;   // decimal cut
        System.out.println("Exact Temp:   " + tempCelsius + "°C");
        System.out.println("Rounded Temp: " + tempRounded + "°C");

        // Price calculation
        double totalBill = 1599.99;
        int    billInt   = (int) totalBill;
        System.out.println("Exact Bill: Rs." + totalBill);
        System.out.println("Truncated:  Rs." + billInt);

        // Safe narrowing - check karo pehle
        double safeVal = 50.5;
        if (safeVal >= Byte.MIN_VALUE && safeVal <= Byte.MAX_VALUE) {
            byte safeByte = (byte) safeVal;
            System.out.println("Safe cast: " + safeByte);
        } else {
            System.out.println("Value out of byte range! Cannot cast safely.");
        }
    }
}

▶ OUTPUT

Exact Temp: 36.6°C
Rounded Temp: 36°C
Exact Bill: Rs.1599.99
Truncated: Rs.1599
Safe cast: 50

💡 Real use case — temperature ya price ko int mein convert karna. Safe narrowing ke liye pehle range check karo.

🟡 Topic 3: char, byte, short ke beech casting

Special Rule — Bahut log miss karte hain! ⚠️

❌ byte  → char  : implicit NAHI hoga (compile error)
❌ char  → byte  : implicit NAHI hoga (compile error)
❌ short → char  : implicit NAHI hoga (compile error)
❌ char  → short : implicit NAHI hoga (compile error)

Kyun nahi hota?

byte  → signed   (-128 to 127)
short → signed   (-32768 to 32767)
char  → unsigned (0 to 65535)  ← DIFFERENT! negative nahi hota

Signed aur Unsigned ke beech automatic conversion UNSAFE hai — isliye Java ne explicitly likhna zaroori kiya.

// Fix:
byte b = 65;
char c = (char) b;  // ✅ explicit cast likhna padega

📁 CharByteCast1.java

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

        // byte → char: explicit cast zaroori
        byte b = 65;
        // char c = b;        // ❌ Compile Error!
        char c = (char) b;    // ✅ explicit cast
        System.out.println("byte 65 → char: " + c);   // A

        // char → byte: explicit cast zaroori
        char ch   = 'Z';
        // byte bVal = ch;    // ❌ Compile Error!
        byte bVal = (byte) ch;  // ✅ explicit cast
        System.out.println("char Z → byte: " + bVal);  // 90
    }
}

▶ OUTPUT

byte 65 → char: A
char Z → byte: 90

💡 byte aur char same size ke hain (almost) but different signs — byte negative ho sakta, char nahi. Isliye explicit cast must hai.

📁 CharByteCast2.java

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

        // short → char: explicit zaroori
        short s = 72;
        // char c = s;        // ❌ Compile Error!
        char  c = (char) s;    // ✅
        System.out.println("short 72 → char: " + c);   // H

        // char → short: explicit zaroori
        char  ch   = 'M';
        // short sVal = ch;   // ❌ Compile Error!
        short sVal = (short) ch;  // ✅
        System.out.println("char M → short: " + sVal);  // 77
    }
}

▶ OUTPUT

short 72 → char: H
char M → short: 77

💡 short signed hai, char unsigned — dono 16-bit hain par different range. Isliye implicit casting blocked hai Java mein.

📁 CharByteCast3.java

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

        // char range: 0 to 65535
        char maxChar   = '\uFFFF';  // max char value
        int  charAsInt = maxChar;
        System.out.println("Max char as int: " + charAsInt);  // 65535

        // Negative byte → char kya hoga?
        byte negByte   = -1;
        char fromNeg   = (char) negByte;  // explicit cast
        int  result    = fromNeg;
        System.out.println("byte -1 → char → int: " + result);  // 65535!
        // -1 ka binary = 11111111 11111111 → char mein 65535 ban gaya
    }
}

▶ OUTPUT

Max char as int: 65535
byte -1 → char → int: 65535

💡 Yahi problem hai! byte -1 ko char mein daalo toh 65535 ban jaata hai — negative value ka meaning change ho gaya. Isliye implicit casting unsafe hai.

📁 CharByteCast4.java

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

        // Saare conversions int ke through safe hote hain

        // char → int → byte (do step)
        char ch = 'A';         // 65
        int  i  = ch;          // char → int : ✅ widening (OK)
        byte b  = (byte) i;   // int → byte : explicit cast
        System.out.println("char A → int: " + i + " → byte: " + b);

        // byte → int → char (do step)
        byte b2 = 66;
        int  i2 = b2;           // byte → int : ✅ widening (OK)
        char c2 = (char) i2;   // int → char : explicit cast
        System.out.println("byte 66 → int: " + i2 + " → char: " + c2);

        // Direct path:
        byte b3 = 67;
        char c3 = (char) b3;   // bhi chalega explicit se
        System.out.println("Direct byte 67 → char: " + c3);
    }
}

▶ OUTPUT

char A → int: 65 → byte: 65
byte 66 → int: 66 → char: B
Direct byte 67 → char: C

💡 Safe way — pehle int mein convert karo (widening), phir jahan chahiye cast karo. Ya direct explicit cast use karo.

🟢 Topic 4: Casting + Arithmetic Expressions

Deep Explanation: Expression mein casting bohot important hai — galat jagah cast karo toh galat answer aata hai.

// ❌ GALAT
int a = 5, b = 2;
double result = a / b;           // pehle int/int = 2, phir 2.0

// ✅ SAHI
double result = (double) a / b;  // pehle 5.0/2, phir 2.5

⚠️ Rule: Cast jo pehle hoti hai woh calculation ko affect karti hai.

📁 CastArithmetic1.java

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

        int a = 7, b = 2;

        // ❌ Wrong - int division pehle hoti hai
        double wrong = a / b;
        System.out.println("Wrong:    " + wrong);   // 3.0

        // ✅ Correct - pehle cast karo
        double correct = (double) a / b;
        System.out.println("Correct:  " + correct);  // 3.5

        // ✅ Dono cast karo
        double correct2 = (double) a / (double) b;
        System.out.println("Correct2: " + correct2); // 3.5
    }
}

▶ OUTPUT

Wrong: 3.0
Correct: 3.5
Correct2: 3.5

📁 CastArithmetic2.java

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

        // Percentage calculate karna
        int scored = 450;
        int total  = 600;

        // ❌ Wrong way
        double wrongPercent = scored / total * 100;
        System.out.println("Wrong  %: " + wrongPercent);   // 0.0

        // ✅ Correct way
        double correctPercent = (double) scored / total * 100;
        System.out.println("Correct%: " + correctPercent);  // 75.0

        // Average
        int    s1  = 80, s2 = 90, s3 = 75;
        double avg = (double)(s1 + s2 + s3) / 3;
        System.out.println("Average: " + avg);               // 81.666...
    }
}

▶ OUTPUT

Wrong %: 0.0
Correct%: 75.0
Average: 81.66666666666667

💡 Real world mein percentage/average calculate karte waqt (double) cast bhul gaye toh 0.0 ya wrong answer milega — yeh common mistake hai!

📋 Complete Revision Summary

Type	Direction	How	Risk
Widening	Chota → Bada byte→short→int→long→float→double	Automatic / Implicit	✅ Safe (mostly)
Narrowing	Bada → Chota	Manual — (type) likhna padta hai	⚠️ Data loss / Overflow
char/byte/short	Inke beech koi bhi	Explicit (type) MUST hai	⚠️ signed vs unsigned
Expression	—	(double)a/b ✅ a/b wrong ❌	⚠️ Wrong result

⚠️ Data Ranges

Type	Size	Range
byte	1 byte	-128 to 127
short	2 bytes	-32,768 to 32,767
int	4 bytes	-2.1B to 2.1B
long	8 bytes	very large
float	4 bytes	decimal (7 digits)
double	8 bytes	decimal (15 digits)
char	2 bytes	0 to 65,535 (unsigned)

⚠️ Common Errors

Error	Reason	Fix
possible lossy conversion	Bina cast ke narrowing	(type) explicitly likho
incompatible types	char↔byte/short without cast	Explicit (char) ya (byte) likho
Result 0.0 ya wrong	int/int division	(double) pehle cast karo
Overflow (-126 for 130)	Value range se bahar	Range check karo pehle

🏆 Golden Rule File name = Class name exactly! Jaise class Widening1 hai toh file Widening1.java hogi!