相关疑难解决方法(0)

设计简单,代码简单但不编译:

public interface Insertable {
    public String getInsertStmt(String table);
}

public class ClassCanBeInserted implements Insertable { 
    public String getInsertStmt(String table) {}
}

public class SomeClass { 
    public static void main() { 
        List<ClassCanBeInserted> list = new ArrayList<ClassCanBeInserted>();
        SomeMethod(list);
    }
    private static void SomeMethod(List<Insertable> list) {}
}

并且对SomeMethod()的调用将无法编译.英语很差,但代码应该解释.有人可以找出什么是错的,以及如何获得一个设计的建议,可以在这种方法中使用接口实现的类列表？

再说一次,英国人很穷,所以可能表达不好.让我知道你的问题.谢谢!

给出的错误消息:类ClassCanBeInserted中的方法SomeMethod(List)不适用于参数(List)

我需要将泛型类传递给类的构造函数.类是SpiceRequest从RoboSpice的Android库来构造参考.

奇怪的是,类需要将泛型类传递给contstructor,当它可以从泛型类型本身访问时,在这种情况下RESULT.class,但是我可能错了.无论如何,我不是要更改库的代码,而是需要使用泛型类型SpiceRequest,Map<String, ? extends Object>.这是我的代码:

SpiceRequest<Map<String, ? extends Object>> request =
        new SpiceRequest<Map<String, ? extends Object>>(???) {
            ...
        };

和SpiceRequest构造函数的签名:

public SpiceRequest(final Class<RESULT> clazz) {
    ...
}

对于??? 我试过Map.class编译错误:The constructor SpiceRequest<Map<String,? extends Object>>(Class<Map>) is undefined.

Map<String, ? extends Object>.class给出错误:Syntax error on tokens, PrimitiveType expected instead特别强调? extends Object.它也给出了相同的错误Map.class.

并且也Map.<String, ? extends Object>class给出了相同的编译器错误.

获取泛型类的正确方法是什么Class<Map<String, ? extends Object>> …

我有一个关于应用多态的问题:让我们假设我有一个类Bird,并且我有许多扩展它的类(比如Pigeon,Falcon依此类推).接下来,我有一Cage堂课.在这堂课中,我想列出一个生活在笼子里的鸟类(只有一种鸟可以生活在每个笼子里).

因此,我不知道列表的扩展类型(A Pigeon？或者可能是Eagle？),我唯一知道的是它将是一个Bird.

如果 Pigeon extends Bird

使用多态性我可以将一只鸟声明为: Bird tom = new Pigeon();而不是Pigeon tom = new Pigeon();

那么为什么我不能在构造函数中初始化类似的东西:[...]

private List<Bird> birdList;

    public Cage() {
        this.birdList = new ArrayList<Pigeon>();
        /* Instead of birdList = new ArrayList<Bird>(); */
    }

如果你不能这样做,是否有可能以另一种方式实现我的目标？

在使用Optional对象时是否有一种有效的方法来执行向上转换.这是一个示例代码:

class A{}
class B extends A{}

B func(){
    //do something
    return new B();
}

Optional<B> func2(){
    //do something
    return Optional.of(new B());
}

main() {
    A a = func(); // Upcasting works fine
    B b = func(); // Upcasting works fine
    Optional<B> b = func2(); // 1. Works fine
    Optional<A> a = func2(); // 2. How to make this work ?
}

(2.)给出错误.我可以通过创建另一个函数来解决它.

但是有一种有效的方法,所以func2()可以用于(1.)和(2.)？

什么时候应该使用像这样的通用多态类型,它的含义是什么？

 1. List<? super Dog> list = new ArrayList<Animal>();
 2. List<? extends Animal> list = new ArrayList<Dog>();
 3. List<?> list = new ArrayList<Dog>();

有人会用这样的东西

List<? super Dog> list = new ArrayList<Dog>();
List<? extends Animal> list = new ArrayList<Animal>();

注意:我理解人们何时使用List<? super Dog>或List<? extends Animal>在方法定义中.但我不明白的是多态泛型类型对象创建.

我正在使用来自第三方库(Reflection)的方法,该方法应该找到给定类型的子类型并且看起来像

public <T> Set<Class<? extends T>> getSubTypesOf(final Class<T> type) {
...

当调用者代码看起来像

Class<?> type = ...
Set<Class<?>> subTypes = reflections.getSubTypesOf(type);

我收到编译错误:" cannot convert from Set<Class<? extends capture#19-of ?>> to Set<Class<?>>".以下修复了这种情况:

Class<?> type = ...
Set<?> subTypes = reflections.getSubTypesOf(ht);

所以看起来不正确的唯一可能的补救措施Set<Class<? extends ?>>是Set<?>,但不是Set<Class<?>>.为什么会这样？谢谢你对此有任何解释.

class A {}

class B extends A {}

class Holder<T> {

    T object;

    Holder(T object) {
        this.object = object;
    }
}

有一个Holder类来保存一些使用泛型创建的对象.在main()中,当使用菱形运算符初始化时,它不会编译(Java 7),派生类传递给Holder的构造函数(需要A /找到B):

public static void main(String[] args) {    
    Holder<A> holder = new Holder<>(new B());        
}

但是,如果在右侧部分指定了基本类型,它将编译并运行:

public static void main(String[] args) {
    Holder<A> holder = new Holder<A>(new B());
}

为什么？钻石操作员是否使用与左侧相同的类型参数定义赋值的右侧部分？

为什么以下代码会出现编译错误？

public MyObject(Builder<? extends MyObject> builder) {
    // Type mismatch: cannot convert from MyObject.Builder<capture#5-of ? extends MyObject> to MyObject.Builder<MyObject>
    Builder<MyObject> myObjBuilder = builder;
}

如果Builder类型是MyObject的子类,那么为什么不能将构建器指定为仅键入MyObject？我需要这样做,因为我无法使用构建器的MyObject类型的对象.看一下这段代码,例如:

public MyObject(Builder<? extends MyObject> builder) {
    // The method getData(capture#8-of ? extends MyObject) in the type Builder<capture#8-of ? extends MyObject> is not applicable for the arguments (MyObject)
    this.data = builder.getData(this);
}

我觉得应该允许这样做.或者我在这里遗漏了什么？有没有办法在不(Builder<MyObject>)使用构建器和必须使用@SuppressWarnings的情况下执行此操作？

还要注意我需要Builder,<? extends MyObject>因为MyObject及其Builder将被子类化(因为它是抽象的).

谢谢你的帮助!

我有一个声明如下的泛型方法

public static <E extends Number> List<E> myListOfElements(List<E> list) {
        return new ArrayList<Integer>();
}

我从中理解的是它期望一个类型的List Number作为输入扩展,List类型Number作为输出扩展.当我尝试返回一个ArrayList<Integer>r时,它会产生编译错误

Type mismatch: cannot convert from ArrayList<Integer> to List<E>

我不明白这里有什么问题.为什么我不能回到ArrayList<Integer>这里？

给出以下Java代码：

import java.util.AbstractMap.SimpleEntry;
import java.util.Arrays;
import java.util.List;
import java.util.Map.Entry;
import java.util.Optional;

public class Test {
    public static void main(String[] args) {
        SimpleEntry<Integer, String> simpleEntry = new SimpleEntry<>(1, "1");
        Optional<Entry<Integer, String>> optionalEntry = Optional.of(simpleEntry);
        Optional<SimpleEntry<Integer, String>> optionalSimpleEntry = Optional.of(simpleEntry);

        List<Entry<Integer, String>> list1 = Arrays.asList(simpleEntry);
        List<Optional<Entry<Integer, String>>> list2 = Arrays.asList(optionalEntry);
        List<Optional<SimpleEntry<Integer, String>>> list3 = Arrays.asList(optionalSimpleEntry);
        List<Optional<Entry<Integer, String>>> list4 = Arrays.asList(optionalSimpleEntry);
    }
}

表达式可以初始化list，list2并且list3可以正常工作。但是，表达式初始化list4在Eclipse中因以下错误而中断：

Type mismatch: cannot convert from List<Optional<AbstractMap.SimpleEntry<Integer,String>>>
to List<Optional<Map.Entry<Integer,String>>>

和此错误javac： …