相关疑难解决方法(0)

可能重复:
是List<Dog>子类List<Animal>吗？为什么Java的泛型不是隐式多态的？

我有这个代码:

ArrayList<A> objects = new ArrayList<A>();

objects.add(new B());

哪个B是儿童班o A.它给我一个编译时错误,如下所示:

类型ArrayList中的方法add(A)不适用于参数(B)

嗨我安静了一个简单的代码,给我一个错误

    void changeHeaders(HttpURLConnection url){
        Map<String, Iterable<String>> m ;
        m = url.getHeaderFields();//<-- this line gives an error
        ...
    }

错误是: Type mismatch: cannot convert from Map<String,List<String>> to Map<String,Iterable<String>>

为什么我无法将List转换为Iterable？

假设我有以下类结构

public abstract class MyClass{}

public class MyClassA extends MyClass{}

public class MyClassB extends MyClass{}

如何创建包含 MyClassA 和 MyClassB 元素且没有异议的 MyClass 元素列表？

例如

    List<MyClass> myList = new LinkedList<MyClassA>();

Java代码:

class Animal {}
class Cat extends Animal {}
class Box<T> {}

public class Test {
    public void hello(Box<? extends Animal> box) {}
}


Box<Animal> box1 = new Box<Animal>();
Box<Cat> box2 = new Box<Cat>();
new Test().hello(box1);
new Test().hello(box2);

从Liskov替换原则,因为box2类型Box<Cat>可以在需要类型的地方使用Box<? extends Animal>,我可以说:

Box<Cat> is subtype of Box<? extends Animal>

其实:我不是,如果甚至不确定Box<? extends Animal>和? extends Animal有型

我可以将ArrayList<HashMap>类型转换为List<Map>Java吗？否则,官方或推荐的解决方法是什么？

我有两个不同但相似类型的接口 - ArrayList<HashMap>而且List<Map>,我需要将数据从一个接口传递到另一个接口.

提前致谢.

我的问题主要涉及这个列表<Dog> List <Animal>的子类？为什么Java的泛型不是隐式多态的？

所以,我们说动物是猫与狗的超级界面.我们还有一个抽象类垃圾

public abstract class Litter{

    public Litter(Collection<Animal> animals){}
}

然后我们自然会有一个具体的类KittyLitter

public class KittyLitter extends Litter{

    public KittyLitter(Collection<Cat> animals) {
        super(animals);
    }
}

......还有小狗垃圾.

当然,我们希望将KittyLitter中的所有Animal限制为Cat.为什么Java不允许我们这样做？然后,还可以说我们添加另一种方法 -

public abstract void addCub(Animal animal);

KittyLitter中的具体实现

@Override
public void addCub(Animal cat) {
    // TODO Auto-generated method stub
}

在这一点上,这打破了逻辑,并允许我们将Dog插入到没有意义的KittyLitter中.关于为什么Java会对我们做这些事情的任何想法？另外,如果可以将KittyLitter构造函数更改为接受List,为什么type参数的行为会有所不同？任何人都可以解释为什么会这样吗？

编辑:这不是关于构造函数,而是任何覆盖的方法.

我有一个方法应该收到一个Class<A>,如:

protected void method(final Class<A> clazz) {
}

然后,当我尝试调用method(A.class)它确实有效,但如果我尝试method(B.class),B孩子在哪里A,我得到消息"不兼容的类型".

解决方案是改变Class<B>,但我有另一个孩子,我喜欢作为参数传递method(),如C.class.

你能解释为什么第一个不起作用吗？

import java.util.ArrayList;
import java.util.List;

public class MyClass {

    private <T extends Object> List<Class<T>> getList1() {
        return new ArrayList<>();
    }

    private <T extends Object> List<Class<T>> getList2(Class<T> cls) {
        List<Class<T>> list = new ArrayList<>();
        list.add(cls);
        return list;
    }

    private List<Class<? extends Object>> getList3() {
        return new ArrayList<>();
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        // 1. Not OK - The method add(Class<Object>) in the type List<Class<Object>> is not applicable for the arguments (Class<String>)
        myClass.getList1().add(String.class);
        // 2. …

我正在尝试制作一个只能包含Numbers的通用List.当我尝试向其添加一个Integer时,它会出现以下错误.

List中的add(T)不能应用于Java.lang.Number

public class QueryHelper<T extends Number> {

    private List<T> records;

    public void query(QueryTypes queryType) {
        records = new ArrayList();
        records.add((Number)new Integer(90));        
    }
}

是什么导致了这个问题？

在下面的代码中

public class Animal {

    public void eat() {
        System.out.println("Animal eating");
    }
}

public class Cat extends Animal {

    public void eat() {
        System.out.println("Cat eating");
    }

}

public class Dog extends Animal {

    public void eat() {
        System.out.println("Dog eating");
    }
}

public class AnimalFeeder {
    public void feed(List<Animal> animals) {
        animals.add(new Cat());
        animals.forEach(animal -> {
            animal.eat();
        });
    }

    public static void main(String args[]){
        List<Animal> a = new ArrayList<Animal>();
        a.add(new Cat());
        a.add(new Dog());

        new AnimalFeeder().feed(a);
     /* List<Dog> dogs = new ArrayList<>(); …