相关疑难解决方法(0)

摘自/sf/answers/1346223371/

public class Test {

    public class A {}

    public class B extends A {}

    public class C extends B {}

    public void testContraVariance(List<? super B> myBlist) {
        B b = new B();
        C c = new C();
        myBlist.add(b);
        myBlist.add(c);
        A a = myBlist.get(0); // does not compile
    }
}

如果 myBlist 接受 B 的超类型，这意味着 B 或 up，那么为什么还可以像中那样向它添加一个子类型myBlist.add(c)？

我对java泛型有点困惑

这是代码

class Base{}

class Derived extends Base{}

我们可以实例化这样的列表

List<? extends Base> list = new ArrayList<Base>();

为什么我不能添加这样的新项目

list.add(new Base()); 

所以用户不能使用"添加"方法作为通配符？在遗传学类型？

谢谢

两者都一样吗？

ParentClass object=new ChildClass();

ParentClass object = (ParentClass) new ChildClass();

如果我想创建一个将字符串映射到Children Objects的地图

"dog"->childA;
"cat"->childB

我该如何申报地图？

Map<String,Parent>
or
Mpa<String,T extends Parent>

我不确定第二个是否正确,但我在某处读到了

我正在尝试创建一个通用列表,它将包含从Object继承的任何类型的项(我假设每个对象都是object类型).

但是,在下面的例子中,当我尝试添加一个String(从对象继承)时,它在Eclipse中显示错误

Error:-The method add(capture#1-of ? extends Object) in the type List<capture#1-of ? extends Object> is not applicable for the arguments (String)


List<? extends Object> alist = new ArrayList<Object>();
alist.add("USA");

有人可以解释为什么我会收到此错误吗？

我在一本java书中发现了这个,并想了解为什么我会收到如下所述的错误:

public class Wildcard<V> {

    V value;

    public Wildcard(V value) {
        super();
        this.value = value;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public boolean sameObj(Wildcard<? extends V> v1, MyComparator<V> comparator) {
        return comparator.compare(this.value, v1.value);
    }

    public static void main(String[] args) {

        Wildcard<Integer> iTest = new Wildcard<Integer>(10);
        Wildcard<Number> nTest = new Wildcard<Number>(10);
        nTest.sameObject(iTest, new MyComparator<Number>() {
            public boolean compare(Number o1, Number o2) {
                return o1 == o2;
            }
        });
    }
} …

我试图理解inhertitance和ArrayList是如何工作的,所以我有以下代码它有一个类,它是保存数据的数据库

public class Database {
    ArrayList<Student> students;
    ArrayList<Course> courses;

    public boolean doesIDExist(ArrayList<RegistrationSystem> array, int id){
       boolean exist = false;
       for (RegistrationSystem array1 : array) {
           if (array1.getId() == id) {
              exist = true;
              break;
           }
       }
       return exist;
    }

    public boolean addStudent(int id, String name, String surname){
       if( doesIDExist(students, id)){
           return false;
       }

       students.add(new Student(id, name, surname));
       return true;
    }

}

学生和课程都是注册系统的子类

public class RegistrationSystem  {
   protected int id;

   public int getId() {
      return id;
   }
}

但是我在这一行中收到错误:

       if( doesIDExist(students, …

整数扩展数字,为什么我在底部得到错误？

interface Predicate<T> {
   public abstract boolean check(T t);
}

Predicate<? extends Number> predUpper = null;

predUpper.check(new Integer(73));

错误:谓词类型中的方法检查(捕获#6-of？extends Number)不适用于参数(整数)

我读过:类型Map <String中的方法,捕获#1-of？extends Object>不适用和<？超级T>和<？在Java中扩展T>

我有Java 8泛型问题.

我有以下类层次结构:

Employee is base class
Manager extends Employee
Executive extends Manager

以下第(1)行无法编译:

(1) List<? super Manager> foos1 = new ArrayList<Executive>(); // error

以下第2行和第3行编译好了:

(2) List<? super Manager> foos2 = new ArrayList<Manager>();   
(3) List<? super Manager> foos3 = new ArrayList<Employee>();  

但是,即使我仍然可以像这样添加Executive:

(4) foos2.add(new Manager("Manager!",123));
(5) foos3.add(new Executive("Executive!",1.0,2));

请解释为什么我不能分配变量的逻辑

<? super Manager> = ArrayList<Executive> 

哪个Executive是Manager的超级管理员,但我仍然可以将Executive对象添加到数组列表中？

非常感谢!

问题与解释

在Java中是否有办法将HashSet<Class>参数移交给方法,以便该方法接受HashSets的子类Class？

如果有一个类的几个子类,这些子类的差异与所讨论的方法无关,那么这将非常有用.如果这是不可能的,那么处理这个的唯一选择似乎就是

• 编写与子类一样多的方法
• 循环遍历调用函数中的HashSet并调用类似的方法,将各个类实例作为参数而不是HashSets

......两者都不太实际.

版本是Java 8(openjdk 1.8.0).

例

假设所有文件都在同一目录中,这样我们就不必担心彼此导入的包和文件.考虑NNB类和子类NNC(NNB的子类).

NNB.java:

import java.util.HashMap;
import java.util.Map;


public class NNB {

    public final Map<Long, Double> dict;

    public NNB () {
        this.dict = new HashMap<Long, Double>();
        int c = 0;
        while (c<10) {
            Long XX = (long)10;
            Double YY = 2.0;
            this.dict.merge(XX, YY, Double::sum); 
            System.out.println(dict);
            c++;
        }
    }
}

NNC.java:

import java.util.HashMap;
import java.util.Map;


public class NNC extends NNB {

    private Map<Long, Double> dict2;

    public NNC …

我执行下面提到的代码时遇到以下错误:

TestGenerics1.java:40: error: cannot find symbol
                              arr.get(i).eat();
                                        ^
symbol:   method eat()
location: class Object
1 error

我将面临的问题在以下示例代码的帮助下重现:

import java.util.*;

abstract class Animal
{
    void eat() { System.out.println("animal eating"); }
}

class Dog extends Animal
{
    void bark() { }
}

class Cat extends Animal
{
    void meow() { }
}

class RedCat extends Cat { }

public class TestGenerics1
{
    public static void main(String[] args)
    {
        new TestGenerics1().go();
    }

    public void go()
    {
        List<Cat> arrAnimals = new ArrayList<Cat>(Arrays.asList(new RedCat(), new …

在下面的代码片段中,它给出了第2行的编译错误,但它不在第3行.

List<? extends Object> list1 = new ArrayList<>(); // line 1
list1.add("123"); // line 2

List<? extends Object> list2 = Arrays.asList("123", new Integer(12)); // line 3

如果语言设计者决定不允许将元素添加到元素类型的集合中,<? extends T>那么它也应该适用于第3行.

造成这种差异的原因是什么？

请澄清.

这是情况...

我必须将List<Object>其传递到代码的相当通用的部分。在某些部分中，列表需要排序。

我不会预先知道列表中是什么类型的对象。但是，通过使用此列表的方式，我保证Comparable该列表中的每个项目都是相同类型并且可以彼此比较的合同。

换句话说，在某些情况下，真正的类型将最终成为String，在其他情况下，Date。在另一些情况下，什么Custom是implements Comparable<Custom>。

但是，在每种情况下，如果实类型为String，则列表中的所有项目均为type String。

让我更具体地说明一下这个问题...

这是我正在研究的课程：

public class Thing {
   private Map<String, List<SourcedValue<Object>>> properties;
}

然后，SourcedValue这是：

public class SourcedValue<T> {
  private T value;
  private List<Sources> sources;
}

那么，您如何建议我宣布这一点？

我不能打电话给serve()下面的方法.

public class GenericService {

   public static class Service<T> {

      public void serve(T t) {
         System.out.println(t.toString());
      }

   }

   public static Service<?> service = new Service<String>();

   public static void main(String[] args) {

      service.serve("Hello World!"); // 'serve(capture<?>)' cannot be applied to '(java.lang.String)'

   }
}

如何强行调用此方法？

为什么Java不喜欢这样的调用？

UPDATE

问题不像ClassCastException提出的那样,因为在那种情况下我可以写

      try {
         service.serve("Hello World!"); // 'serve(capture<?>)' cannot be applied to '(java.lang.String)'
      }
      catch (ClassCastException e) {
         System.err.println("You see!? This is why I was disliking your code!");
      }

但我不能.

为什么？

更新2 …