{"title":"Type Casting","description":"","content":"Java is strict about types. A value with one type doesn't automatically become another type unless the conversion is safe, and when it isn't safe, an explicit cast is required. This lesson covers how the two kinds of conversion work between primitive types, why Java forces explicit casts for lossy conversions, and the small handful of arithmetic rules to watch for. The lesson closes with a brief look at casting between reference types so the term `(String) something` isn't a mystery on first sight.\n\n---\n\n# Two Kinds of Conversion\n\nThere are exactly two ways one primitive type turns into another in Java:\n\n- **Widening conversion:** a smaller type fits into a bigger type. Java handles this automatically with no syntax. No information is lost.\n- **Narrowing conversion:** a bigger type has to be squeezed into a smaller type. Java refuses to do this silently because data can be lost. An explicit cast is the way to tell the compiler \"yes, I know, do it anyway.\"\n\nThe compiler enforces this split because dropping precision or wrapping a number around without warning is a common bug. Widening is always safe, so it happens automatically. Narrowing is sometimes safe and sometimes a disaster, so the compiler hands the responsibility back to the developer.\n\nThe same idea in table form:\n\n\n| Kind | Direction | Cast needed? | Data loss possible? | Example |\n|------|-----------|--------------|---------------------|---------|\n| Widening | small to big | No | No | `int orderCount = 5; long total = orderCount;` |\n| Narrowing | big to small | Yes | Yes | `double subtotal = 89.95; int rounded = (int) subtotal;` |\n\n\nThe next few sections unpack both directions.\n\n---\n\n# Widening: The Free Conversion\n\nA widening conversion takes a value of a smaller type and stores it in a variable of a bigger type. Every value that fits in the smaller type also fits in the bigger one, so nothing has to be dropped. Java performs the conversion automatically.\n\n\n```java\npublic class WideningOrderCount {\n public static void main(String[] args) {\n int orderCount = 250;\n long totalOrders = orderCount; // int widens to long, no cast needed\n double averageRating = orderCount; // int widens to double, no cast needed\n\n System.out.println(\"Order count: \" + orderCount);\n System.out.println(\"Total orders (long): \" + totalOrders);\n System.out.println(\"Average rating slot (double): \" + averageRating);\n }\n}\n```\n\n\nThe last line: `250` printed as `250.0`. The value didn't change, but the type did. A `double` always has a decimal part, so Java tacks on `.0` when it widens an integer.\n\nThe full chain of widening conversions for numeric types runs from `byte` all the way up to `double`. Anything earlier in the chain widens automatically to anything later.\n\n\n```mermaid\nflowchart LR\n BYTE[byte
1 byte]:::cyan --> SHORT[short
2 bytes]:::cyan\n SHORT --> INT[int
4 bytes]:::orange\n INT --> LONG[long
8 bytes]:::orange\n LONG --> FLOAT[float
4 bytes]:::green\n FLOAT --> DOUBLE[double
8 bytes]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nA `byte` widens to a `short`, an `int`, a `long`, a `float`, or a `double`. A `long` widens to a `float` or a `double`. The chain is one-way: nothing later in the chain widens to something earlier.\n\nOne thing that looks odd at first: `long` widens to `float`, even though a `long` is 8 bytes and a `float` is only 4 bytes. The conversion is still classified as widening because `float` can represent numbers far larger than any `long`. What it can't always do is represent them exactly. A very large `long` might land on the nearest `float` value, losing a little precision in the last digits. The compiler still treats this as widening and allows it without a cast.\n\n---\n\n# Narrowing: When You Need a Cast\n\nNarrowing is the other direction: a bigger type squeezed into a smaller one. The bigger type can hold values the smaller one cannot, so the conversion can lose data. Java refuses to do this automatically; a cast is required.\n\nThe syntax is simple: put the target type in parentheses in front of the value to convert.\n\n\n```java\npublic class NarrowingSubtotal {\n public static void main(String[] args) {\n double subtotal = 89.95;\n int wholeDollars = (int) subtotal; // double to int, decimal chopped off\n\n long bigCount = 5_000_000_000L;\n int truncatedCount = (int) bigCount; // long to int, value too big\n\n System.out.println(\"Subtotal: \" + subtotal);\n System.out.println(\"Whole dollars: \" + wholeDollars);\n System.out.println(\"Big count: \" + bigCount);\n System.out.println(\"Truncated count: \" + truncatedCount);\n }\n}\n```\n\n\nTwo different kinds of damage happened here, and both are worth understanding.\n\nThe first line, `(int) 89.95`, turned `89.95` into `89`. Casting a `double` to an `int` throws away the fractional part. It doesn't round. `89.95` becomes `89`, `89.99` becomes `89`, and `(int) 3.99` is `3`. For rounding, use `Math.round` explicitly.\n\nThe second cast, from a `long` value of 5 billion down to an `int`, gave back `705032704`, which has no obvious relationship to the original. An `int` only has 32 bits, and 5 billion needs more. When the value doesn't fit, Java keeps the low 32 bits and discards the rest. The result is whatever bit pattern those low 32 bits represent, interpreted as a signed `int`. The compiler doesn't warn, because the cast already declared this is the intended behavior.\n\nA smaller example makes the wraparound easier to see:\n\n\n```java\npublic class ByteWraparound {\n public static void main(String[] args) {\n int orderCount = 300;\n byte smallCount = (byte) orderCount;\n\n System.out.println(\"Original count: \" + orderCount);\n System.out.println(\"As byte: \" + smallCount);\n }\n}\n```\n\n\nA `byte` holds values from -128 to 127. 300 is well outside that range. The cast keeps the low 8 bits of `300`, which work out to `44`. There's no error, no warning, just a wrong number. This is why Java forces the explicit cast: the compiler wants the developer to confirm this is the intended behavior.\n\nNarrowing casts have no runtime overhead, but they have a real correctness cost. If the source value doesn't fit in the target type, the result is a wrong number. Check ranges before casting, or use `Math.toIntExact` for `long` to `int` conversions that should throw on overflow.\n\n---\n\n# Cast Syntax in One Place\n\nA cast is one piece of syntax: `(targetType) value`. The parentheses go around the type, not the value. The cast applies to the single expression that follows it. Here's the same shape in a few contexts:\n\n\n```java\npublic class CastSyntax {\n public static void main(String[] args) {\n double price = 12.5;\n int quantity = 3;\n\n int wholePrice = (int) price; // cast a variable\n int total = (int) (price * quantity); // cast the result of an expression\n long widePrice = (long) price; // narrowing from double to long\n\n System.out.println(\"Whole price: \" + wholePrice);\n System.out.println(\"Total: \" + total);\n System.out.println(\"Wide price: \" + widePrice);\n }\n}\n```\n\n\nLook at the second line carefully: `(int) (price * quantity)`. The cast applies only to the result of `price * quantity`, because the parentheses make the multiplication happen first. Without those inner parentheses, `(int) price * quantity` would cast `price` to `int` first (turning `12.5` into `12`), then multiply by `3`, giving `36` instead of `37`. The placement of parentheses matters.\n\n---\n\n# `char` and `int` Convert Both Ways\n\n`char` is an integer type in Java. It holds a 16-bit unsigned number that represents a character code. Because it's a number internally, it widens to `int` automatically, and an `int` can be cast back to a `char`.\n\n\n```java\npublic class CharIntConversion {\n public static void main(String[] args) {\n char letter = 'A';\n int code = letter; // char widens to int, no cast\n int next = letter + 1; // 'A' + 1 is arithmetic on ints\n\n char nextLetter = (char) next; // narrowing back to char requires a cast\n\n System.out.println(\"Letter: \" + letter);\n System.out.println(\"Code: \" + code);\n System.out.println(\"Next code: \" + next);\n System.out.println(\"Next letter: \" + nextLetter);\n }\n}\n```\n\n\n`'A'` has the character code `65`. The line `int code = letter;` widens the `char` to an `int`, so `code` is `65`. The expression `'A' + 1` is `65 + 1`, which is `66`, also an `int`. Getting back to a `char` requires a cast: `(char) 66` is `'B'`. This is the standard way to walk through an alphabet of category codes or shift letters by a fixed amount.\n\n---\n\n# Mixed-Type Arithmetic Promotes Operands\n\nWhen types mix in an arithmetic expression, Java picks a single type to do the math in. The rules are predictable:\n\n- If either operand is a `double`, both are promoted to `double`.\n- Otherwise, if either operand is a `float`, both are promoted to `float`.\n- Otherwise, if either operand is a `long`, both are promoted to `long`.\n- Otherwise, both operands are promoted to `int`.\n\nIf two `byte` values or two `short` values are added, the result is an `int`, not a `byte` or a `short`. Java promotes anything smaller than `int` up to `int` before doing arithmetic.\n\n\n```java\npublic class MixedArithmetic {\n public static void main(String[] args) {\n int quantity = 4;\n double price = 19.99;\n double cartTotal = price * quantity; // int promoted to double\n\n long bigOrders = 10_000_000_000L;\n int recentOrders = 50;\n long combined = bigOrders + recentOrders; // int promoted to long\n\n byte itemA = 10;\n byte itemB = 20;\n // byte sum = itemA + itemB; // does not compile, result is int\n int itemSum = itemA + itemB;\n\n System.out.println(\"Cart total: \" + cartTotal);\n System.out.println(\"Combined orders: \" + combined);\n System.out.println(\"Item sum: \" + itemSum);\n }\n}\n```\n\n\nThe commented-out line is the case to note. `itemA` and `itemB` are both `byte`. Their sum is mathematically `30`, which fits in a `byte`. But Java promoted both to `int` before adding, so the result has type `int`, and the assignment to a `byte` is a narrowing conversion that requires a cast:\n\n\n```java\nbyte itemA = 10;\nbyte itemB = 20;\nbyte itemSum = (byte) (itemA + itemB); // works with an explicit cast\n```\n\n\nThis rule exists because the JVM does all its integer arithmetic at `int` width or wider. Promoting smaller types to `int` keeps the bytecode simple. The trade-off is that arithmetic on `byte` and `short` keeps producing `int` results, and casts are needed to push them back down.\n\n---\n\n# The Compound Assignment Shortcut\n\nThe compound assignment operators (`+=`, `-=`, `*=`, `/=`, `%=`) have a small but useful quirk: they perform an implicit narrowing cast back to the variable's type. The version below compiles even though the equivalent long-form does not.\n\n\n```java\npublic class CompoundAssignment {\n public static void main(String[] args) {\n byte itemsInCart = 10;\n itemsInCart += 5; // compiles, implicit cast back to byte\n // itemsInCart = itemsInCart + 5; // does not compile\n\n System.out.println(\"Items in cart: \" + itemsInCart);\n }\n}\n```\n\n\nThe line `itemsInCart += 5;` is effectively `itemsInCart = (byte) (itemsInCart + 5);`. The compiler inserts the cast automatically. The expanded form `itemsInCart = itemsInCart + 5;` does not get that free cast, so it fails to compile with the same \"incompatible types\" error as any other narrowing without a cast.\n\nThis shortcut is handy, but it has the same data-loss risk as any other narrowing. `byte total = 120; total += 50;` wraps to `-86`, because `170` doesn't fit in a `byte`. The implicit cast doesn't change the math; it just skips writing the cast.\n\n---\n\n# Reference Casting at a Glance\n\nEverything above is about primitive types. Reference types (objects) can also be cast, but the rules are different and the topic deserves its own treatment.\n\nThe short version: a reference of a parent type that actually points to an object of a more specific child type can be cast down to the child type to use the child's features. The most common case is `Object` holding a `String`:\n\n\n```java\npublic class ReferenceCastPreview {\n public static void main(String[] args) {\n Object stored = \"wireless-headphones\";\n String productId = (String) stored; // reference cast\n\n System.out.println(\"Length: \" + productId.length());\n }\n}\n```\n\n\nThe cast doesn't change the object; it changes how the compiler sees the reference. If the object pointed to isn't really a `String`, the cast throws `ClassCastException` at runtime. There's no truncation here, just a clean failure when the assumption is wrong.\n\nFor now, the syntax `(String) someObject` exists, it looks like a primitive cast, and it does something different internally.","pageType":"java"}

Type Casting

Get Premium