Java最佳实践 - 返回对象与通用(Java Best Practices - Returning an Object vs. a Generic)

 我第一次在学校项目中使用泛型，我遇到了一个关于是否在我的方法中返回对象或我声明的泛型元素的哲学困境。 
 
 我的OCD告诉我，我需要始终返回已知类型，但我发现当我将原始数据类型提供给我的类时，这样做会产生一些下游烦恼（当然，对于这个项目，我只会提供原语进入这个班）。 
 
 这是我的意思的一个例子： 
 
public class DansPriorityQueue<E extends Comparable> 
{
    private ArrayList<E> tree;

//Here's a method that returns an object
public Object peek() {
    return tree.get(0);
}

//Here's a method that returns the generic type
public E peek() {
    return tree.get(0);
}
 
 （作为一个FYI ..我需要自己实现这个JDK类，但幸运的是我不需要实现真正的PriorityQueue所做的相同接口，所以我可以选择是否要使用Object或者泛型） 
 
 我的问题 
 
 它让我觉得有点脏，但我很想在这些方法上返回一个Object而不是我的E泛型元素，因为当我返回E时，JUnit强制我强制转换整数值： 
 
DansPriorityQueue<Integer> dpq = new DansPriorityQueue<Integer>();
dpq.add(1);
assertEquals("Expected different value", (Integer) 1, dpq.peek());
 
 另一方面，当我返回一个对象时，自动装箱不会强迫我施放原始值。 
 
 以下是我所面临的问题的更有说服力的描述： 
 
 http://www.aschroder.com/2009/10/php-1-java-0-the-method-assertequalsobject-object-is-ambiguous-for-the-type/ 
 
  - - - - - - 编辑 - - - - - - - -  
 
 这是我返回泛型类型并使用自动装箱的Integer对象填充我的列表而没有上面的强制转换时收到的实际错误：方法assertEquals（String，Object，Object）对于DansPriorityQueueTest类型是不明确的 
 
 ---------结束编辑-------------- 
 
 问题 
 
 
 
 任何人都可以告诉我为什么我应该或不应该返回一个对象而不是我正在使用的通用元素？ 两者似乎都有好处和缺点......什么是最佳做法？ 
 
 
 我隐约知道返回一个Object会导致一些转换问题，但我还没有碰到它们......有没有人有一个具体的例子说明这可能是危险的？ 
 
 
 在JDK中，我注意到许多Collections方法默认返回Object。 这是因为Generics是在Java的更高版本中引入的还是Sun Systems的有意识的决定？ 
 

I'm using Generics for the first time for a school project and I have come across a philosophical dilemma regarding whether to return objects or my declared generic element in my methods. 
 
My OCD is telling me that I need to always return the known type but I'm finding that doing so creates some downstream annoyances when I feed primitive datatypes into my class (and, of course, for this project I'm only ever feeding primitives into this class).
 
Here's an example of what I mean:
 
public class DansPriorityQueue<E extends Comparable> 
{
    private ArrayList<E> tree;

//Here's a method that returns an object
public Object peek() {
    return tree.get(0);
}

//Here's a method that returns the generic type
public E peek() {
    return tree.get(0);
}
 
(As an FYI.. I'm required to implement this JDK class myself but I am fortunately not required to implement the same interfaces that the real PriorityQueue does so I do have a choice as to whether I want to use the Object or the generic)
 
My Issue
 
It makes me feel a little dirty but I'm tempted just to return an Object rather than my E generic element on these methods because when I return E, JUnit forces me to cast my integer values:
 
DansPriorityQueue<Integer> dpq = new DansPriorityQueue<Integer>();
dpq.add(1);
assertEquals("Expected different value", (Integer) 1, dpq.peek());
 
When I return an object on the other hand, the auto-boxing doesn't force me cast my primitive value.
 
Here's a more eloquent description of the issue I've been facing:
 
http://www.aschroder.com/2009/10/php-1-java-0-the-method-assertequalsobject-object-is-ambiguous-for-the-type/
 
------------EDIT----------------
 
Here's the actual error I receive when I return the generic type and fill my list with the autoboxed Integer object without the cast above: The method assertEquals(String, Object, Object) is ambiguous for the type DansPriorityQueueTest
 
--------- END EDIT--------------
 
Questions
 
 
 
Can anyone tell me why I should or should not return an object as opposed to the generic element I'm working with? Both seem to have upsides and downsides... what's the best practice?
 
 
I know vaguely that returning an Object can cause some casting issues later on but I've not yet run into them... does anyone have a specific example of how this can be dangerous?
 
 
In the JDK, I've noticed that many of the Collections methods return Object by default. Is this because Generics was introduced in a later version of Java or was this a conscious decision by Sun Systems?
 

原文：https://stackoverflow.com/questions/19863006