Java Type Casting: Widening, Narrowing, and Conversions

What Type Casting Means

Java is statically typed: every value has a type, and the compiler will not let you silently mix incompatible ones. Type casting is how you convert a value from one type to another - sometimes Java does it for you, and sometimes you have to ask for it explicitly.

There are two directions. Going from a smaller type to a larger one (an int into a double) is safe and happens automatically. Going from a larger type to a smaller one (a double into an int) can lose data, so Java forces you to spell it out with a cast.

Widening: The Automatic Conversion

A widening conversion moves a value into a type with more room. Nothing can be lost, so Java does it for you without a cast:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automatic

        System.out.println(price);   // 7.0
    }
}

The int 7 slots into a double and becomes 7.0. The widening order for numbers is byte -> short -> int -> long -> float -> double; assigning leftward-to-rightward along that chain never needs a cast. This is why mixing types in arithmetic often "just works" - Java widens the smaller operand first.

Narrowing: The Explicit Cast

Going the other way - a narrowing conversion - can drop data, so the compiler refuses unless you put the target type in parentheses in front of the value:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // explicit narrowing cast

        System.out.println(whole);   // 3, not 4
    }
}

(int) pi is the cast. Note what it does: it truncates toward zero, simply discarding the decimal part. 3.9 becomes 3, and -3.9 becomes -3. It does not round. If you want rounding, that is a different tool:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (truncates)
        System.out.println(Math.round(value));    // 4  (rounds)
    }
}

Forgetting that a cast truncates is one of the most common beginner bugs - if your "rounded" number is always one too low, this is usually why.

The Integer Division Trap

This gotcha bites everyone once. When both operands are int, the / operator does integer division and throws away the remainder - before any assignment to a double happens:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - division done as ints first!
        double right = (double) a / b; // 3.5  - cast one operand first

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b is 7 / 2, computed entirely in int math, which gives 3. Widening to double afterward only turns 3 into 3.0 - the .5 is already gone. Casting one operand to double first ((double) a / b) forces the whole expression into floating-point, giving the 3.5 you wanted. You only need to cast one side; Java widens the other to match.

When Narrowing Overflows

A cast does not check whether the value fits. If it does not, the bits are simply chopped and you get a surprising result - no error, no warning:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte only holds -128..127

        System.out.println(small);   // 44, not 300
    }
}

300 does not fit in a byte, so the high bits are discarded and you get 44. This is "silent" data loss - the program runs fine and gives a wrong answer. Only narrow when you are sure the value fits the smaller type.

Converting Between Numbers and Strings

A String is an object, not a number, so you cannot cast it with (int) - that is a compile error. Conversion uses dedicated methods instead:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Going from text to a number uses Integer.parseInt / Double.parseDouble. If the string is not a valid number (say "hello"), these throw a NumberFormatException. Going from a number to text, use String.valueOf(n) or just concatenate with "" - because n + "" forces the int into a String. Watch out for the difference between "5" + 1 (which gives the string "51") and 5 + 1 (which gives 6); the + means concatenation the moment a String is involved.

Casting Objects

Casting also applies to object references, not just primitives. You can cast a reference to a related type along an inheritance chain - widening to a parent type is automatic, narrowing back down needs an explicit cast and is only safe if the object really is that type:

Object o = "hello";
String s = (String) o;        // OK: o actually refers to a String
Integer bad = (Integer) o;    // compiles, but throws ClassCastException at runtime

The second cast compiles but blows up at runtime with a ClassCastException because the object is a String, not an Integer. You will meet this properly once you reach inheritance and polymorphism; for now, just know the (Type) syntax is the same idea applied to objects.

Next: if-else

Casting lets you reshape values; the next step is making your program choose between paths based on those values. The if-else statement runs one block when a condition is true and another when it is false - the foundation of every decision your code makes. That is the next page.