2

我们有一个类结构，例如A<-B<-C<-D<-E<-F（ B 扩展 A，C 扩展 B 等等）。

我需要以acceptList(List<> list)这样的方式创建一个方法，它可以接受ListClassA,C,E并且不接受 List of B,D,F。

这个问题是在一次采访中问我的。

4

4 回答 4

2

像这样的一些技巧可能会起作用，请记住接口总是会击败反射......因此，如果您可以直接在接口中实现那些依赖于类型的函数，那么就去做吧。

首先你的类的实现：

public class A {

public boolean isAcceptable() {
    return true;
}

static class B extends A {

    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class C extends B {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class D extends C {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class E extends D {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class F extends E {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

}

然后你的acceptList(~)：

public static boolean acceptList(List<? extends A> list){
    for (A a : list) {
        if(!a.isAcceptable()){
            return false;
        }
    }
    return true;
}
于 2013-08-28T10:54:54.597 回答
1

也许使用条件 -if和isInstance()？

于 2013-08-28T10:44:38.637 回答
0

不可能，您只能指定允许的类而不是不允许的类。

此外，一旦一个方法被定义为接受List<? extends A>它接受的 a List<A>，List<B>, List<C>,...

于 2013-08-28T10:44:27.620 回答
0

泛型不允许区分。类型擦除将发挥其作用..我建议您编写如下自定义逻辑：

public class Test {

public boolean accept(List<? extends A> list) {
    for (Object o : list) {
        if (o instanceof E && !(o instanceof F))
            return true;
        else if (o instanceof C && !(o instanceof D) && !(o instanceof F))
            return true;
        else if (o instanceof A && !(o instanceof B) && !(o instanceof D) && !(o instanceof F))
            return true;
        return false;
    }
    return false;

}

}

class A {

}

class B extends A {

}

class C extends B {

}

class D extends C {

}

class E extends D {

}

class F extends E {

}

测试上述代码的测试方法：

public static void main(String [] args){

    Test t = new Test();

    List<F> listF = new ArrayList<F>();
    listF.add(new F());
    System.out.println("List of F returns "+ t.accept(listF));

    List<E> listE = new ArrayList<E>();
    listE.add(new E());
    System.out.println("List of E returns "+ t.accept(listE));

    List<D> listD = new ArrayList<D>();
    listD.add(new D());
    System.out.println("List of D returns "+ t.accept(listD));

    List<C> listC = new ArrayList<C>();
    listC.add(new C());
    System.out.println("List of C returns "+ t.accept(listC));

    List<B> listB = new ArrayList<B>();
    listB.add(new B());
    System.out.println("List of B returns "+ t.accept(listB));

    List<A> listA = new ArrayList<A>();
    listA.add(new A());
    System.out.println("List of A returns "+ t.accept(listA));
}

测试输出：

List of F returns false
List of E returns true
List of D returns false
List of C returns true
List of B returns false
List of A returns true

编辑：

如果您想进行更多研究，这可能会对您有所帮助。获取 java.util.List 的泛型类型

于 2013-08-28T10:56:15.150 回答