ArrayList既然继承自AbstractList抽象类，而AbstractList已经实现了List接口，那么ArrayList类为何还要再实现List接口呢？

男娘i 2024-02-19 16:56 14阅读 0赞

之前碰到过这个问题，就想搞清楚这块，有的说Josh Bloch在编写集合框架时出现的一个小错误，但我感觉像这种级别的牛人，这么写应该有其他作用，找了这样一篇文章，来证明这块是出于精心设计的。原谅我是一名gangjing转自原文如下

转自：http://www.cnblogs.com/bluejavababy/p/4320545.html

首先请看下面这段代码：

![复制代码][copycode.gif]

package example;
    
    import java.io.Serializable;
    import java.util.Arrays;
    
    public class Test {
    
     public static interface MyInterface {
      void foo();
     }
    
     public static class BaseClass implements MyInterface, Cloneable, Serializable {
    
      @Override
      public void foo() {
       System.out.println("BaseClass.foo");
      }
     }
    
     public static class Class1 extends BaseClass {
    
      @Override
      public void foo() {
       super.foo();
       System.out.println("Class1.foo");
      }
     }
    
     static class Class2 extends BaseClass implements MyInterface, Cloneable,
       Serializable {
    
      @Override
      public void foo() {
       super.foo();
       System.out.println("Class2.foo");
      }
     }
    
     public static void main(String[] args) {
    
      showInterfacesFor(BaseClass.class);
      showInterfacesFor(Class1.class);
      showInterfacesFor(Class2.class);
     }
    
     private static void showInterfacesFor(Class<?> clazz) {
      System.out.printf("%s --> %s\n", clazz, Arrays.toString(clazz
        .getInterfaces()));
     }
    }

![复制代码][copycode.gif]

输出的结果为：

class example.Test$BaseClass --> [interface example.Test$MyInterface, interface java.lang.Cloneable, interface java.io.Serializable]
    class example.Test$Class1 --> []
    class example.Test$Class2 --> [interface example.Test$MyInterface, interface java.lang.Cloneable, interface java.io.Serializable]

从结果可以看出虽然Class1类的父类实现了接口，但是本身并没有再次实现接口，因此通过java.lang.Class直接获取Class1类的接口为空数组。

因此，在实现代理的时候就会出现问题，请看下面的代码：

![复制代码][copycode.gif]

package example;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    import example.Test.BaseClass;
    import example.Test.Class1;
    import example.Test.Class2;
    
    public class Test2 extends Test {
    
     public static void main(String[] args) {
    
      MyInterface c1 = new Class1();
      MyInterface c2 = new Class2();
    
      // Note the order...
      MyInterface proxy2 = createProxy(c2);
      proxy2.foo();
    
      // This fails with an unchecked exception
      MyInterface proxy1 = createProxy(c1);
      proxy1.foo();
     }
    
     private static <T> T createProxy(final T obj) {
    
      final InvocationHandler handler = new InvocationHandler() {
    
       @Override
       public Object invoke(Object proxy, Method method, Object[] args)
         throws Throwable {
        System.out.printf("About to call %s() on %s\n", method
          .getName(), obj);
        return method.invoke(obj, args);
       }
      };
    
      return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), handler);
     }
    }

![复制代码][copycode.gif]

输出结果为：

About to call foo() on example.Test$Class2@578ceb
    BaseClass.foo
    Class2.foo
    Exception in thread "main" java.lang.ClassCastException: $Proxy1 cannot be cast to example.Test$MyInterface
     at example.Test2.main(Test2.java:23)

可以看出Class1实现接口代理时，就会报异常。

因此，这并不是一个错误，很可能是作者Josh Bloch为了便于实现代理而精心设计的。

参考：http://stackoverflow.com/questions/2165204/why-does-linkedhashsete-extend-hashsete-and-implement-sete

[copycode.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/5b08d35296484a8a9c7d011674c5458e.png