isAssignableFrom() 证实了Java是非纯面向对象语言

人有见识就不轻易发怒；宽恕人的过失便是自己的荣耀

---

今天回顾了一下Glide源码，然后在ImageViewTargetFactory看到新鲜东西。

public class ImageViewTargetFactory {
  @NonNull
  @SuppressWarnings("unchecked")
  public <Z> ViewTarget<ImageView, Z> buildTarget(
      @NonNull ImageView view, @NonNull Class<Z> clazz) {
    if (Bitmap.class.equals(clazz)) {
      return (ViewTarget<ImageView, Z>) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
      return (ViewTarget<ImageView, Z>) new DrawableImageViewTarget(view);
    } else {
      throw new IllegalArgumentException(
          "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
    }
  }
}

上述代码中的 isAssignableFrom() 显得格外引人注目。

 /** 
 	 * 区分调用者是否是参数cls的本身，或者是其父类or父接口。特别声明，如果是基本类型，则需精确匹配。
 	 * 
 	 * Determines if the class or interface represented by this
     * {@code Class} object is either the same as, or is a superclass or
     * superinterface of, the class or interface represented by the specified
     * {@code Class} parameter. It returns {@code true} if so;
     * otherwise it returns {@code false}. 
     * 
     * @exception NullPointerException if the specified Class parameter is
     *            null.(该方法会抛出 NPE(NullPointerException) )
     * @since JDK1.1
     */
    public boolean isAssignableFrom(Class<?> cls) {
        if (this == cls) {
            return true;  // Can always assign to things of the same type.
        } else if (this == Object.class) {
            return !cls.isPrimitive();  // Can assign any reference to java.lang.Object.
        } else if (isArray()) {
            return cls.isArray() && componentType.isAssignableFrom(cls.componentType);
        } else if (isInterface()) {
            // Search iftable which has a flattened and uniqued list of interfaces.
            Object[] iftable = cls.ifTable;
            if (iftable != null) {
                for (int i = 0; i < iftable.length; i += 2) {
                    if (iftable[i] == this) {
                        return true;
                    }
                }
            }
            return false;
        } else {
            if (!cls.isInterface()) {
                for (cls = cls.superClass; cls != null; cls = cls.superClass) {
                    if (cls == this) {
                        return true;
                    }
                }
            }
            return false;
        }
    }

我们通过测试，来验证一下该方法的功能，进而来探测一下基本类型和Object,以及其对应的包装类的关系：

 public static void main(String[] args) {
	 	System.out.println("Object 和 常用类的继承关系");
        System.out.println(Object.class.isAssignableFrom(Class.class)); // true
        System.out.println(Object.class.isAssignableFrom(String.class)); // true
        System.out.println(Object.class.isAssignableFrom(Runnable.class)); // true
        System.out.println(Object.class.isAssignableFrom(Integer.class)); // true
        System.out.println("Object 和 基本类型的继承关系");
        System.out.println(Object.class.isAssignableFrom(int.class)); // false
        System.out.println(Object.class.isAssignableFrom(double.class)); // false
        System.out.println(Object.class.isAssignableFrom(boolean.class)); // false
        System.out.println("基本类型和其对应的包装类的继承关系");
        System.out.println(Integer.class.isAssignableFrom(int.class)); // false
        System.out.println(Double.class.isAssignableFrom(double.class)); // false
        System.out.println(Boolean.class.isAssignableFrom(boolean.class)); // false
 }

总结

基本类型(boolean,int, double and so on…)和Object,以及其对应的包装类(Boolean, Integer, Double and so on…)在继承关系上没有什么关系。这也从侧面证明了Java不是纯面向对象语言。