Java类型转换，对象类型和重载问题

Question

Please have a look on following Class, I need to check if there is valid value in the variable. All works fine if there is a proper value in variable instead of null , When it comes null the behaviour is not what I expect (Although it might make sense if Integer a = null; when checked as a instanceof Integer ,

Can some one guide me how to achieve correct result from following class?

package com.mazhar.hassan;

public class ValueChecker {
    public static boolean empty(Integer value) {
        System.out.println("Integer");
        return (value != null && value.intValue() > 0);
    }
    public static boolean empty(Long value) {
        System.out.println("Long");
        return (value != null && value.longValue() > 0);
    }
    public static boolean empty(String value) {
        System.out.println("String");
        return (value != null && value.length() > 0);
    }
    public static boolean empty(Object value) {
        System.out.println("Object");
        return (value != null);
    }
    public static void checkAll(Object... args) {
        for(Object o: args) {
            if (o instanceof Integer) {
                empty((Integer)o);
            }
            else if (o instanceof Long) {
                empty((Long)o);
            }
            else if (o instanceof String) {
                empty((String)o);
            }
            else {
                empty(o);
            }
        }
    }
    public static void main (String[] args) {
        Integer a = null;
        Long b =  null;
        String x = null;
        Object y = null;

        if (a instanceof Integer) {
            System.out.println("a is Integer");
        } else {
            System.out.println("a is not Integer");
        }

        System.out.println("/---------------------------------------------------/");
        checkAll(a,b,x,y);
        System.out.println("/---------------------------------------------------/");
        empty(a);
        empty(b);
        empty(x);
        empty(y);
    }
}

Why I need exact type checking is, I thave to throw erros like "Not valid Integer", "No valid Long" etc.

The output of above class is as follows.

/-----------------------(Output 1)----------------------------/
a is not Integer
/-----------------------(Output 2)----------------------------/
Object
Object
Object
Object
/------------------------(Output 3)---------------------------/
Integer
Long
String
Object

Output 1: a is not integer (checked by instanceof) can not recognize it but when passed to a overloaded function goes to the right function (Output 3)

Output 2: How to achieve checkAll with multiple/dynamic param checkAll(varInt, varLong, varString, varObject)

Answer 1

The behaviour for Output 1 is caused by the fact that method overloads are bound at compile time. So the specific overload to pick is bound before the program even runs. instanceof , on the other hand, is a runtime check.

Thus, at runtime a instanceof Integer is effectively null instanceof Integer , which is obviously false .

But for each of those individual method calls, the proper method is called because the compiler bound the specific overload of the method at compile time, based on the reference type of the variable. Thus:

empty(a); // Compiled to a call to empty(Integer value)
empty(b); // Compiled to a call to empty(Long value)
empty(x); // Compiled to a call to empty(String value)
empty(y); // Compiled to a call to empty(Object value)

So regardless of the actual object that a , b , x , and y reference, you'll always get the right output on your console for the respective object.

---

Output 2: How to achieve checkAll with multiple/dynamic param checkAll(varInt, varLong, varString, varObject)

Well, if you're going to pass null , you can't really. null is null at runtime, and doesn't have any type information associated with it. The JVM can't tell that one null is a " String null " or an " Object null ". It's just null . So you can't really implement the multiple check you want to for null inputs -- null instanceof ______ will always return false , so you'll always end up with your default case.

If you pass actual objects, though, that method should work properly.

Answer 2

problem:

    Integer a = null;
    Long b =  null;
    String x = null;
    Object y = null;

You cant use instanceof on null values, it expect the objects to be instantiated thus giving you wrong result.

solution:

instantaite the object first before you check for instance.

Answer 3

The problem here is that when you check instanceof in your loop, you are checking null . null is not an instance of anything, it is the absence of an instance.

If you want to achieve something like this, you're going to have to change your API for checkAll(Object ...) to something that tells the function what types to expect:

public class ValueChecker {
    public static boolean checkAll(Object[] args, Class<?>[] types) {
        if (args == null || types == null || args.length != types.length)
            throw new RuntimeException("programming error");
        for (int i = 0; i < args.length; i++) {
            if (types[i] == null)
                throw new RuntimeException("programming error");
            if (args[i] == null || !types[i].isAssignableFrom(args[i].getClass())) {
                System.out.println("arg " + (i +1) + " is not " + types[i].getSimpleName());
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Integer a = null;
        Long b =  null;
        String x = null;
        Object y = null;

        checkAll(
                new Object[] {a, b, x, y},
                new Class<?>[] {Integer.class, Long.class, String.class, Object.class}
        );
    }
}