如果你看一下这个简短的代码剪切,是否有实际调用baz
的有效方法?
public class Foo {
static class Bar<T> {
public void baz(Class<? extends List<T>> cls) {
}
}
public static void main(String[] args) {
Bar<String> bar = new Bar<>();
// does not compile
bar.baz(ArrayList<String>.class);
bar.baz((Class<List<String>>) ArrayList.class);
bar.baz(new ArrayList<String>().getClass());
}
}
答案 0 :(得分:0)
我可以想到两种方式(它们都有缺点):
1
Bar bar = new Bar<>();
bar.baz(ArrayList.class);
这当然会删除您可能不需要的String
类型参数。
2
Bar<String> bar = new Bar<>();
bar.baz(MyClass.class);
此处,MyClass
被声明为ArrayList<String>
的包装:
class MyClass implements List<String> {
private ArrayList<String> inner = new ArrayList<>();
@Override
public int size() {
return inner.size();
}
@Override
public boolean isEmpty() {
return inner.isEmpty();
}
@Override
public boolean contains(Object o) {
return inner.contains(o);
}
@Override
public Iterator<String> iterator() {
return inner.iterator();
}
@Override
public Object[] toArray() {
return inner.toArray();
}
@Override
public <T> T[] toArray(T[] a) {
return inner.toArray(a);
}
@Override
public boolean add(String s) {
return inner.add(s);
}
@Override
public boolean remove(Object o) {
return inner.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return inner.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends String> c) {
return inner.addAll(c);
}
@Override
public boolean addAll(int index, Collection<? extends String> c) {
return inner.addAll(index, c);
}
@Override
public boolean removeAll(Collection<?> c) {
return inner.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return inner.retainAll(c);
}
@Override
public void clear() {
inner.clear();
}
@Override
public String get(int index) {
return inner.get(index);
}
@Override
public String set(int index, String element) {
return inner.set(index, element);
}
@Override
public void add(int index, String element) {
inner.add(index, element);
}
@Override
public String remove(int index) {
return inner.remove(index);
}
@Override
public int indexOf(Object o) {
return inner.indexOf(o);
}
@Override
public int lastIndexOf(Object o) {
return inner.lastIndexOf(o);
}
@Override
public ListIterator<String> listIterator() {
return inner.listIterator();
}
@Override
public ListIterator<String> listIterator(int index) {
return inner.listIterator(index);
}
@Override
public List<String> subList(int fromIndex, int toIndex) {
return inner.subList(fromIndex, toIndex);
}
}
这样做的缺点当然是浪费时间来创建一个实现List<String>
的全新类。如果你很懒,可以尝试扩展AbstractList<String>
。