Java Type Casting: Widening, Narrowing, instanceof & ClassCastException

Type casting tells the Java compiler to treat a value as a different type. Java supports two kinds of casting: widening conversions, which are safe and automatic (int to long, Dog to Animal), and narrowing conversions, which may lose information and require an explicit cast operator (long to int, Animal to Dog). Incorrect narrowing of reference types throws ClassCastException at runtime. This article covers both numeric and reference casting, safe-cast patterns with instanceof, and the modern pattern-matching instanceof syntax.

Share

Widening Conversions: Automatic and Safe

A widening conversion promotes a value to a broader type that can represent all the same values and more. Because no information is lost, the compiler performs widening automatically without requiring any syntax from the programmer. For primitives, widening follows the chain: byte → short → int → long → float → double and char → int. For reference types, widening means assigning a subtype to a supertype variable, a Dog reference stored in an Animal variable, which is always safe because Dog is guaranteed to satisfy the Animal contract.

Widening can introduce subtle numeric precision loss in one case: converting a large int or long to float or double. Floating-point numbers have limited mantissa bits, so very large integers cannot be represented exactly. The conversion still compiles without a cast and without a warning: you must be aware of this yourself.

Java
// Primitive widening — automatic
byte  b = 42;
short s = b;        // byte → short (automatic)
int   i = s;        // short → int  (automatic)
long  l = i;        // int → long   (automatic)
float f = l;        // long → float (automatic — but may lose precision!)
double d = f;       // float → double (automatic)

// Precision loss example
int big = 123_456_789;
float imprecise = big;           // widening: int → float
System.out.println(big);         // 123456789
System.out.println(imprecise);   // 1.23456792E8 — last digits lost!
System.out.println((int) imprecise); // 123456792 — not the original value

// Reference widening — also automatic
class Animal { String name; }
class Dog extends Animal {}

Dog dog = new Dog();
Animal animal = dog;   // widening: Dog → Animal (no cast needed)
Object obj = animal;   // widening: Animal → Object (no cast needed)

Narrowing Numeric Conversions

A narrowing conversion converts a value to a type with a smaller range. For primitives this means going down the widening chain: double → float → long → int → short → byte. The compiler requires an explicit cast operator (targetType) because the conversion may lose data: either the high-order bits are silently truncated, or the fractional part of a floating-point number is dropped.

The truncation rules for integer narrowing are deterministic but surprising. When casting a long to an int, Java keeps only the low 32 bits, discarding the upper 32 bits entirely. The result wraps around rather than saturating at Integer.MAX_VALUE. When casting a floating-point to an integer, the fractional part is truncated toward zero, and if the value is outside the integer range, the result is the minimum or maximum integer value (or zero for NaN).

Java
// Integer narrowing — truncates bits
long big = 300L;
int  narrow = (int) big;          // OK: 300 fits in int
System.out.println(narrow);       // 300

long overflow = 3_000_000_000L;
int truncated = (int) overflow;   // 3_000_000_000 > Integer.MAX_VALUE
System.out.println(truncated);    // -1294967296  (bit truncation, not an error!)

// Floating-point to integer — drops fractional part, clamps at range limits
double pi = 3.99;
int piInt = (int) pi;             // truncates toward zero → 3 (not rounded!)
System.out.println(piInt);        // 3

double huge = 1e18;
int hugeInt = (int) huge;         // out of int range → Integer.MAX_VALUE (2147483647)
System.out.println(hugeInt);

double nan = Double.NaN;
int nanInt = (int) nan;           // NaN → 0
System.out.println(nanInt);       // 0

// byte/short narrowing — keeps low-order bits
int  val = 200;
byte b   = (byte) val;            // 200 in binary = 11001000; as signed byte = -56
System.out.println(b);            // -56

// char ↔ int narrowing and widening
char  c = 'A';
int   code = c;                   // widening: char → int (65)
char  back = (char) 66;           // narrowing: int → char ('B')
System.out.println(code + " " + back); // 65 B
Numeric narrowing never throws an exception: it silently produces a wrong value. Always validate that the value is within the target type's range before casting if data integrity matters. Use Math.toIntExact(long) to convert long to int safely: it throws ArithmeticException on overflow instead of silently truncating.

Reference Casting and ClassCastException

Narrowing a reference type, casting a supertype to a subtype, is called a downcast. The compiler allows it because it cannot determine at compile time whether the actual runtime object is of the target type. The JVM performs the type check at runtime and throws ClassCastException if the object's actual type is not compatible with the target type. A ClassCastException is an unchecked RuntimeException: the compiler will not force you to handle it.

The safe way to downcast is to check the runtime type first with instanceof. If instanceof returns true, the subsequent cast is guaranteed to succeed.

Java
class Animal { String sound() { return "..."; } }
class Dog extends Animal { String fetch() { return "fetching!"; } }
class Cat extends Animal { String purr()  { return "purring!"; } }

Animal a1 = new Dog();  // widening: Dog stored as Animal
Animal a2 = new Cat();  // widening: Cat stored as Animal

// Unsafe downcast — ClassCastException if wrong type
Dog d = (Dog) a1;            // OK: actual type IS Dog
System.out.println(d.fetch()); // fetching!

try {
    Dog fail = (Dog) a2;     // WRONG: actual type is Cat
} catch (ClassCastException e) {
    System.out.println("Cannot cast Cat to Dog: " + e.getMessage());
}

// Safe downcast — check with instanceof first
if (a2 instanceof Cat) {
    Cat c = (Cat) a2;        // guaranteed to succeed
    System.out.println(c.purr());
}

// Java 16+ — pattern matching instanceof (combines check and cast)
if (a1 instanceof Dog dog) {
    System.out.println(dog.fetch()); // 'dog' is already typed as Dog
}

// Useful in switch for dispatch over a hierarchy
Object obj = 42;
String description = switch (obj) {
    case Integer i -> "Integer: " + i;
    case String  s -> "String: " + s;
    default        -> "Other: " + obj;
};
System.out.println(description); // Integer: 42

Casting with Interfaces and Arrays

Reference casting also applies to interfaces. An object can be cast to any interface type it implements, regardless of where in the hierarchy the interface is declared. The JVM verifies at runtime that the actual object implements the target interface.

Arrays have their own casting rules. An array of a subtype is a subtype of an array of the supertype, Dog[] is a Animal[]: which is Java's array covariance. This is a historical design decision that can cause surprising ArrayStoreException at runtime when you assign an incompatible element to the array through the supertype reference.

Java
// Interface casting
interface Serializable {}
interface Printable { void print(); }

class Document implements Serializable, Printable {
    @Override public void print() { System.out.println("Document"); }
}

Object obj = new Document();
Printable p = (Printable) obj;    // valid: Document implements Printable
p.print();

Serializable ser = (Serializable) obj; // also valid

// Array covariance — safe widening
Dog[] dogs = { new Dog(), new Dog() };
Animal[] animals = dogs;          // widening: Dog[] → Animal[] (automatic)

// Array store check — throws ArrayStoreException at runtime
try {
    animals[0] = new Cat();       // ← putting a Cat into a Dog[] via Animal[] ref
} catch (ArrayStoreException e) {
    System.out.println("Cannot store Cat in Dog[]: " + e.getMessage());
}

// instanceof with arrays
System.out.println(dogs instanceof Animal[]); // true — due to covariance
System.out.println(dogs instanceof Dog[]);    // true
System.out.println(dogs instanceof Cat[]);    // false
Array covariance (Dog[] assignable to Animal[]) was a design choice made before generics existed. Generic collections with proper wildcards (List<? extends Animal>) are type-safe at compile time. Prefer generic collections over arrays when working with polymorphic types.

Related articles

All Java articles →
Java Data Types: Primitives, Wrappers, and Reference TypesJava Data Types: all 8 primitive types, wrapper classes, autoboxing, type casting, BigDecimal for precision, integer overflow, and reference types.Java - Pattern Matching for instanceof (Java 16+)Pattern Matching for instanceof in Java 16: eliminates explicit casts after instanceof checks. Covers binding variables, scope rules, and practical examples.Java Arrays: Declaration, Multi-dimensional, and Arrays UtilityJava Arrays: declaring, initializing, multi-dimensional arrays, and the Arrays utility class for sorting, searching, copying and filling.Interfaces: Default, Static and Private MethodsJava interfaces since Java 8: default, static and private methods, and how they relate to functional interfaces, with examples.