Java Wrapper.isConvertibleFrom方法代码示例

import sun.invoke.util.Wrapper; //导入方法依赖的package包/类
static boolean canConvert(Class<?> src, Class<?> dst) {
    // short-circuit a few cases:
    if (src == dst || src == Object.class || dst == Object.class)  return true;
    // the remainder of this logic is documented in MethodHandle.asType
    if (src.isPrimitive()) {
        // can force void to an explicit null, a la reflect.Method.invoke
        // can also force void to a primitive zero, by analogy
        if (src == void.class)  return true;  //or !dst.isPrimitive()?
        Wrapper sw = Wrapper.forPrimitiveType(src);
        if (dst.isPrimitive()) {
            // P->P must widen
            return Wrapper.forPrimitiveType(dst).isConvertibleFrom(sw);
        } else {
            // P->R must box and widen
            return dst.isAssignableFrom(sw.wrapperType());
        }
    } else if (dst.isPrimitive()) {
        // any value can be dropped
        if (dst == void.class)  return true;
        Wrapper dw = Wrapper.forPrimitiveType(dst);
        // R->P must be able to unbox (from a dynamically chosen type) and widen
        // For example:
        //   Byte/Number/Comparable/Object -> dw:Byte -> byte.
        //   Character/Comparable/Object -> dw:Character -> char
        //   Boolean/Comparable/Object -> dw:Boolean -> boolean
        // This means that dw must be cast-compatible with src.
        if (src.isAssignableFrom(dw.wrapperType())) {
            return true;
        }
        // The above does not work if the source reference is strongly typed
        // to a wrapper whose primitive must be widened.  For example:
        //   Byte -> unbox:byte -> short/int/long/float/double
        //   Character -> unbox:char -> int/long/float/double
        if (Wrapper.isWrapperType(src) &&
            dw.isConvertibleFrom(Wrapper.forWrapperType(src))) {
            // can unbox from src and then widen to dst
            return true;
        }
        // We have already covered cases which arise due to runtime unboxing
        // of a reference type which covers several wrapper types:
        //   Object -> cast:Integer -> unbox:int -> long/float/double
        //   Serializable -> cast:Byte -> unbox:byte -> byte/short/int/long/float/double
        // An marginal case is Number -> dw:Character -> char, which would be OK if there were a
        // subclass of Number which wraps a value that can convert to char.
        // Since there is none, we don't need an extra check here to cover char or boolean.
        return false;
    } else {
        // R->R always works, since null is always valid dynamically
        return true;
    }
}
 

import sun.invoke.util.Wrapper; //导入方法依赖的package包/类
private void testUnbox(boolean doCast, Wrapper dst, Wrapper src) throws Throwable {
    boolean expectThrow = !doCast && !dst.isConvertibleFrom(src);
    if (dst == Wrapper.OBJECT || src == Wrapper.OBJECT)  return;  // must have prims
    if (dst == Wrapper.VOID   || src == Wrapper.VOID  )  return;  // must have values
    if (dst == Wrapper.OBJECT)
        expectThrow = false;  // everything (even VOID==null here) converts to OBJECT
    try {
        for (int n = -5; n < 10; n++) {
            Object box = src.wrap(n);
            switch (src) {
                case VOID:   assertEquals(box, null); break;
                case OBJECT: box = box.toString(); break;
                case SHORT:  assertEquals(box.getClass(), Short.class); break;
                default:     assertEquals(box.getClass(), src.wrapperType()); break;
            }
            MethodHandle unboxer;
            if (doCast)
                unboxer = ValueConversions.unboxCast(dst);
            else
                unboxer = ValueConversions.unboxWiden(dst);
            Object expResult = (box == null) ? dst.zero() : dst.wrap(box);
            Object result = null;
            switch (dst) {
                case INT:     result = (int)     unboxer.invokeExact(box); break;
                case LONG:    result = (long)    unboxer.invokeExact(box); break;
                case FLOAT:   result = (float)   unboxer.invokeExact(box); break;
                case DOUBLE:  result = (double)  unboxer.invokeExact(box); break;
                case CHAR:    result = (char)    unboxer.invokeExact(box); break;
                case BYTE:    result = (byte)    unboxer.invokeExact(box); break;
                case SHORT:   result = (short)   unboxer.invokeExact(box); break;
                case BOOLEAN: result = (boolean) unboxer.invokeExact(box); break;
            }
            if (expectThrow) {
                expResult = "(need an exception)";
            }
            assertEquals("(doCast,expectThrow,dst,src,n,box)="+Arrays.asList(doCast,expectThrow,dst,src,n,box),
                         expResult, result);
        }
    } catch (RuntimeException ex) {
        if (expectThrow)  return;
        System.out.println("Unexpected throw for (doCast,expectThrow,dst,src)="+Arrays.asList(doCast,expectThrow,dst,src));
        throw ex;
    }
}