Java Casting method without knowing what to cast to

Question

I was playing around with Java today, and I noticed something weird. Consider this code:

String foo = cast("hi");
int bar = cast("1");

The cast() method is here:

public static <T> T cast(Object value) {
    return (T) value;
}

Java seems to cast "hi" to a String, even if I didn't pass any hint that it would be a String, with the exception of the type. It does foo well, but fails on bar, because you can't case a String to an Integer. What is happening here?

I have two guesses:

The cast method is returning an Object, and at initialization it automatically casts to the type.

This doesn't make sense, as it would give me:
```
 Type mismatch: cannot convert from Object to int
```
Java seems to know that it needs to cast to String, or whatever the type of the variable is. But how does this work?

@KLibby It's declared in the method. It says `public static T cast(Object value) {`. Notice the ``. — TheCoffeeCup, Dec 27 '15 at 01:49
The second one gives me a runtime exception, not a compile time error. Is that what you are talking about? — markspace, Dec 27 '15 at 01:52
Well, there's a difference between Eclipse and Java. Java doesn't yell at you until run time. — markspace, Dec 27 '15 at 01:54
@KLibby - This is a generic method; it has nothing to do with generic classes. Even if the class were generic with a type parameter named `T`, the type parameter for the method would shadow the class's parameter. — Ted Hopp, Dec 27 '15 at 01:57
Reinventing the wheel? `String str = String.class.cast(obj);` — Bohemian, Dec 27 '15 at 01:58

Anthony Raymond · Answer 1 · 2015-12-27T02:08:55.777

8

public static <T> T cast(Object value) {
    return (T) value;
}

The important part is the <T> on the method, it means that the method will return a type based on what the method call expect.

String foo = cast("hi"); // left side is a String, <T> will be typed as String

The second is a bit more tricky since Generic types cannot be primitive types. I guess it returns the most common type Object.

int bar = cast("1"); // left side is primitive
                     // <T> will be typed by with the corresponding non-primitive type.
                     // But it fails because "1" cannot be casted to java.lang.Integer

edited Dec 27 '15 at 02:08

answered Dec 27 '15 at 01:54

Anthony Raymond

7,434
6
42
59

1

I think for `int` that it is actually cast to Integer. That's the error message I get: `java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer` – markspace Dec 27 '15 at 01:58
yeah, nice magic in the air :) ok, primitives seems to be replaced by they non-primitive classes. @markspace thansk, i fixed my mistake. – Anthony Raymond Dec 27 '15 at 02:01
@AnthonyRaymond It's called auto-unboxing – Erwin Bolwidt Dec 27 '15 at 03:19

score 6 · Accepted Answer · edited May 23 '17 at 11:52

Your cast method does an unchecked conversion, which is handled specially in the JVM to maintain backward compatibility with non-generic code.

Such calls cannot be shown to be statically safe under the type system using generics. Rejecting such calls would invalidate large bodies of existing code, and prevent them from using newer versions of the libraries. JLS 5.1.9

Calling the method without explicit type parameters will cause the compiler to infer the type parameter of the invocations, in this case based on their expected return type. Type Inference, JLS 15.12.2.7.. This means that code is equvivalent to this:

String foo = Caster.<String>cast("hi"); // no exception
int bar = Caster.<Integer>cast("1");    // runtime ClassCastException

Primitive types will inferred to their boxed version:

If A is a primitive type, then A is converted to a reference type U via boxing conversion and this algorithm is applied recursively to the constraint U << F. JLS 15.12.2.7.

The JVM ensures type safety by doing runtime type checks on return values of functions containing unchecked casts, at the first point where the type information is not erased (I didn't find it explicitly stated in the specification, but things look to work this way, although it is mentioned in The Java Tutorials). In this case, where you try to assign the value to a typed local variable, the type of the return value is checked, resulting in a ClassCastException.

To give some more idea when that enforced runtime type checking cast happens, here are a few more examples:

Object a3 = Caster.<String>cast(3); // no exception, a3 is now Integer
Object a4 = (String)Caster.<String>cast(3); // an explicit cast causes runtime ClassCastException

EDIT:

Here is a StackOverflow question about when are runtime type checks enforced: When is generic return value of function casted after type erasure?

score 0 · Answer 3 · answered Dec 27 '15 at 02:07

I don't see any weird behaviour.

In:

String foo = cast("hi");

"hi" is an Object (as everything in Java), so it would be accepted by the compiler as an Object argument. After the call, the cast() function returns "hi", which is a string, and it is assigned to String foo. No weird behavior here.

In:

int bar = cast("1");

"1" is an object, and it is accepted by the compiler. The castfunction returns "1", which is a string. Unlike other languages (e.g. Javascript), a string cannot be directly casted as an integer. No weird behavior here.

If you change the cast() function to:

public static <T> T cast(T value) {
    return value;
}

You will get an error in compile time, instead of execution time.

score 0 · Answer 4 · answered Apr 09 '19 at 09:09

If anyone need to cast primitive types as well, can refer to this.

public class ReflectionTests {

@Test
public void TEST_PRIMITIVE_TYPE_CAST() {
    Object myNumber=123456;
    int number=ReflectionUtils.cast(myNumber);
    assertTrue(number==123456);

    int numberTest2=ReflectionUtils.castPrimitiveType(myNumber, myNumber.getClass().getName());
    assertTrue(numberTest2==123456);

    double numberTest3=ReflectionUtils.castPrimitiveType(myNumber, "double");
    assertTrue(numberTest3==123456);
}

 }

These tests passes, here below related part from my ReflectionUtils

public static <T> T cast(Object value) {
    if(value.getClass().isPrimitive())
        return castPrimitiveType(value, value.getClass().getName());
    return (T) value;
}

public static <T> T castPrimitiveType(Object value,String typeName) {       
    switch (typeName) {
    case "double":
        return (T) castToDouble(value);
    case "byte":
        return (T) castToByte(value);
    case "int":         
        return (T) castToInt(value);
    case "long":            
        return (T) castToLong(value);           
    case "float":           
        return (T) castToFloat(value);              
    default:
        break;
    }
    return (T) value;
}

public static Boolean castToBoolean(Object val) {
    return Boolean.valueOf(val.toString());
}

public static Byte castToByte(Object val) {     
    return Byte.valueOf(val.toString());
}

public static Character castToChar(Object val) {
    return Character.valueOf(val.toString().charAt(0));
}

public static Integer castToInt(Object val) {
    return Integer.valueOf(val.toString());
}

public static Long castToLong(Object val) {
    return Long.valueOf(val.toString());
}

public static Float castToFloat(Object val) {
    return Float.valueOf(val.toString());
}

public static Double castToDouble(Object val) {
    return Double.valueOf(val.toString());
}

Java Casting method without knowing what to cast to

4 Answers4

Linked