Type casting: widening and narrowing

The average that lost its decimals

What is type casting?

Words you'll meet in this lesson

The widening ladder

Kinds of conversions

Casting vs converting between text and numbers

How Java decides the type of an expression

1. Look at each operand's type

   In total / 5, total is int and 5 is an int literal.

   javac works this out at compile time and chooses the bytecode instruction: idiv for ints, ddiv for doubles.

2. Promote small types to int

   byte, short and char become int before any arithmetic.

   The JVM has no byte-addition instruction at all. Small values are loaded as ints, which is why byte + byte is an int.

3. Widen to the biggest type present

   If either side is long, float or double, the other side is widened to match.

   For (double) total / 5, the cast happens first (it binds tighter than /), so 437.0 / 5 uses ddiv and gives 87.4.

4. Do the operation in that type

   int ÷ int = int (fraction dropped). double ÷ int = double.

   The result's type is fixed. Assigning an int result to a double variable widens it afterwards; the lost fraction can't come back.

5. Assign, widening automatically or casting explicitly

   Storing into a bigger type is automatic. Storing into a smaller one needs a cast, or javac reports “possible lossy conversion”.

   A narrowing cast compiles to instructions like d2i (double to int) or i2b (int to byte), which drop bits or decimals.

What a cast does to the bits: both views

Left: the code and what prints. Right: the value inside memory before and after.

Where conversions bite in real systems

Conversions are everywhere data crosses a boundary: from the database, the network, a file or a calculation.

Watch it with an example: a product's average rating

Three customers rate a phone cover 5, 4 and 5 stars. Watch how integer division loses the fraction, and how one cast fixes it.

Examples are simplified to show where conversions happen. Real systems vary.

Riya's marks, converted correctly

public class Main {
    public static void main(String[] args) {
        int total = 437;
        double wrongAvg = total / 5;            // int division first
        double avg = (double) total / 5;        // cast first
        int whole = (int) avg;                  // truncates
        long rounded = Math.round(avg);         // rounds
        byte squeezed = (byte) 300;             // keeps lowest 8 bits
        int parsed = Integer.parseInt("42");    // text to number

        System.out.println(wrongAvg + " vs " + avg);
        System.out.println(whole + " " + rounded + " " + squeezed + " " + parsed);
    }
}

• total / 5int ÷ int = int (87). Widened to 87.0 only afterwards.
• (double) total / 5The cast applies to total first, so the division is done in double.
• (int) avgNarrowing: drops .4. It never rounds up.
• Math.round(avg)Rounds to the nearest whole number and returns a long.
• (byte) 300Only the lowest 8 bits survive: 44.
• Integer.parseInt("42")Text to number is parsing, not casting.

Every conversion, step by step

Watch each value change type. The note shows the bytecode conversion instruction where one happens.

Worked examples: real problems, solved and traced in memory

Casting changes a value from one type to another. Widening (int → double) is automatic and safe; narrowing (double → int, long → int) needs an explicit cast and can lose data. These programs show both, with real business numbers.

total stars 13, reviews 3

int division: 4
average: 4.333333333333333
whole stars shown: 4

amount 3000000000

long: 3000000000, cast to int: -1294967296
refused: integer overflow

seat row 'H'; row number 3

Row H is number 8
Number 3 is row C

Check yourself

Quick revision

Interview and viva questions

Practice problems

Widen automatically, narrow with care. Predict each output before running. The last three are business tasks.

50

50.0

public class Main {
    public static void main(String[] args) {
        int i = 50;
        double d = i;
        System.out.println(d);
    }
}

9.99

9

public class Main {
    public static void main(String[] args) {
        System.out.println((int) 9.99);
    }
}

'0', '9'

48 57

public class Main {
    public static void main(String[] args) {
        System.out.println((int) '0' + " " + (int) '9');
    }
}

'7'

8

public class Main {
    public static void main(String[] args) {
        char c = '7';
        int digit = c - '0';
        System.out.println(digit + 1);
    }
}

7.6

7 8

public class Main {
    public static void main(String[] args) {
        double x = 7.6;
        System.out.println((int) x + " " + Math.round(x));
    }
}

37, 40

Achieved 92.5%

public class Main {
    public static void main(String[] args) {
        int sold = 37, target = 40;
        double pct = (double) sold / target * 100;
        System.out.println("Achieved " + pct + "%");
    }
}

250, 24

Cartons: 11

public class Main {
    public static void main(String[] args) {
        int cartons = (int) Math.ceil(250 / 24.0);
        System.out.println("Cartons: " + cartons);
    }
}

129.95

cast: 12994 paise, rounded: 12995 paise

public class Main {
    public static void main(String[] args) {
        double rupees = 129.95;
        long cast = (long) (rupees * 100);
        long rounded = Math.round(rupees * 100);
        System.out.println("cast: " + cast + " paise, rounded: " + rounded + " paise");
    }
}

Real-world scenario questions (asked in company interviews)

Conversion bugs don't crash; they quietly produce wrong numbers. Decide your answer first, then open the model answer.