JAVA 的重载是运行时决定还是编译的时候决定？正确使用泛型

参考链接： 重载Java中的main()

首先看个例子 

第一个片段A的部分 传入的实际类型是String希望调用C片段，但是实际上是调用的B。   

敲黑板：Java的泛型是运行时就擦除了的。  不要出现参数数量一样的方法重载，可能出错不说，而且完全不清晰。  T 会擦除成Object。  调哪个编译时就确定了。 

我们看下Optional的泛型如何可以准确找到isEmpty(String s) 

Optional<String> str = Optional.of("me");

        str.ifPresent(v->{

            boolean exit = Util.isEmpty(v);

        }); 

解决和建议： 

一个是去掉泛型，避免同一后再细化。第二种是修改重载的部分如下： 

 public static <T> void ifNotEmpty(T t, Consumer<? super T> consumer) {

    if (!isEmpty(t)) {

        consumer.accept(t);

    }

    }

    public static boolean isEmpty(Object obj) {

    if (obj == null)

        return true;

    Class<?> clazz = obj.getClass();

    if (clazz.isArray()) {

        if (clazz == byte[].class) // eClass.getComponentType() == byte.class

        return ((byte[]) obj).length == 0;

        if (clazz == short[].class)

        return ((short[]) obj).length == 0;

        if (clazz == int[].class)

        return ((int[]) obj).length == 0;

        if (clazz == long[].class)

        return ((long[]) obj).length == 0;

        if (clazz == char[].class)

        return ((char[]) obj).length == 0;

        if (clazz == float[].class)

        return ((float[]) obj).length == 0;

        if (clazz == double[].class)

        return ((double[]) obj).length == 0;

        if (clazz == boolean[].class)

        return ((boolean[]) obj).length == 0;

        Object[] objArr = (Object[]) obj;

        return objArr.length == 0;

    }

    if (String.class.isAssignableFrom(clazz)) {

        return ((String) obj).length() == 0;

    }

    if (Map.class.isAssignableFrom(clazz)) {

        return ((Map<?, ?>) obj).size() == 0;

    }

    if (Collection.class.isAssignableFrom(clazz)) {

        return ((Collection<?>) obj).size() == 0;

    }

    throw new SysException("unkown classType {}", clazz.getCanonicalName());

    }

另外判断类型是否是某个接口的子类实现或者本身的正确姿势 

    System.out.println(Map.class.isAssignableFrom(HashMap.class));

    System.out.println(null instanceof String);

    System.out.println(String.class.isInstance("a")); 

正确使用泛型 

下面两段代码是一样的 

 public static  boolean isEmpty(Collection<?> t) {

    return null == t || 0 == t.size();

    }

    public static <T extends Collection<?>> boolean isEmpty(T t) {

    return null == t || 0 == t.size();

      } 

编译后： 

public static boolean isEmpty(java.util.Collection<?>);

    Code:

       0: aconst_null

       1: aload_0

       2: if_acmpeq     15

       5: iconst_0

       6: aload_0

       7: invokeinterface #2,  1            // InterfaceMethod java/util/Collection.size:()I

      12: if_icmpne     19

      15: iconst_1

      16: goto          20

      19: iconst_0

      20: ireturn

  public static void main(java.lang.String[]);

    Code:

       0: new           #3                  // class java/util/ArrayList

       3: dup

       4: invokespecial #4                  // Method java/util/ArrayList."<init>":()V

       7: astore_1

       8: aload_1

       9: invokestatic  #5                  // Method isEmpty:(Ljava/util/Collection;)Z

      12: pop

      13: return 

第二种为 

 public static <T extends java.util.Collection<?>> boolean isEmpty(T);

    Code:

       0: aconst_null

       1: aload_0

       2: if_acmpeq     15

       5: iconst_0

       6: aload_0

       7: invokeinterface #2,  1            // InterfaceMethod java/util/Collection.size:()I

      12: if_icmpne     19

      15: iconst_1

      16: goto          20

      19: iconst_0

      20: ireturn

  public static void main(java.lang.String[]);

    Code:

       0: new           #3                  // class java/util/ArrayList

       3: dup

       4: invokespecial #4                  // Method java/util/ArrayList."<init>":()V

       7: astore_1

       8: aload_1

       9: invokestatic  #5                  // Method isEmpty:(Ljava/util/Collection;)Z

      12: pop

      13: return 

可以看到main方法中在编译后已经指定具体方法了  如果我们将main函数的代码修改如下 

public static void main(String args[]){

    List<Object> list = new ArrayList<>();

    Object o = list;

    isEmpty(o);

    } 

反编译会发现调用的是isEmpty(Object o)而不是isEmpty(Collection list),即不是根据实际类型来寻找具体的重载方法,而是在编译的时候就已经决定了 

public static void main(java.lang.String[]);

    Code:

       0: new           #3                  // class java/util/ArrayList

       3: dup

       4: invokespecial #4                  // Method java/util/ArrayList."<init>":()V

       7: astore_1

       8: aload_1

       9: astore_2

      10: aload_2

      11: invokestatic  #5                  // Method isEmpty:(Ljava/lang/Object;)Z

      14: pop

      15: return