InventoryItem.java使用未经检查或不安全的操作

时间:2014-03-25 02:48:05

标签: java compiler-errors

我正在学习可比性,并且正在我的库存类中实现它。但是当我编译代码时,编译器会出错。

InventoryItem.java uses unchecked or unsafe operations.

任何人都可以帮助我。我的代码有什么问题,我该怎么做才能解决这个问题。提前谢谢你的帮助。

class InventoryItem implements Comparable<InventoryItem>
{
    private String name;
    private int uniqueItemID;

    public InventoryItem()
    {
            name = " ";
            uniqueItemID = 0;
    }

    public InventoryItem(String newName, int newItemID)
    {
            name = newName;
            uniqueItemID = newItemID;
    }

    public InventoryItem(InventoryItem i)
    {
            name = i.name;
            uniqueItemID = i.uniqueItemID;
    }

    public void setName(String newName)
    {
            name = newName;
    }

    public void setItemID(int newItemID)
    {
            uniqueItemID = newItemID;
    }

    public int getItemID()
    {
            return uniqueItemID;
    }

    public String getName()
    {
            return name;
    }

    public int compareTo(InventoryItem i)
    {
            int anotherUniqueID = i.getItemID();
            return (this.uniqueItemID - anotherUniqueID);
    }

    public static void sort(Comparable[] a, int numberUsed)
    {
            int index, indexOfNextSmallest;

            for(index = 0; index < numberUsed - 1; index++)
            {
                    indexOfNextSmallest = indexOfSmallest(index, a, numberUsed);
                    interchange(index, indexOfNextSmallest, a);
            }
    }

    private static int indexOfSmallest(int startIndex, Comparable[] a, int numberUsed)
    {
            Comparable min = a[startIndex];
            int indexOfMin = startIndex;
            int index;

            for(index = startIndex + 1; index < numberUsed; index++)
            {
                    if(a[index].compareTo(min) < 0)
                    {
                            min = a[index];
                            indexOfMin = index;
                    }
            }
            return indexOfMin;
    }

    private static void interchange(int i, int j, Comparable[] a)
    {
            Comparable temp;
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
    }
}

public class InventoryItemTester
{
    public static void main(String [] args)
    {
            InventoryItem[] items = new InventoryItem[3];

            items[0] = new InventoryItem("Pens", 2);
            items[1] = new InventoryItem("Pencils", 3);
            items[2] = new InventoryItem("Notebooks", 1);

            System.out.println("Before sorting");
            System.out.println(items[0]);
            System.out.println(items[1]);
            System.out.println(items[2]);


            InventoryItem.sort(items, items.length);

            System.out.println("After sorting");
            System.out.println(items[0]);
            System.out.println(items[1]);
            System.out.println(items[2]);
    }
}

1 个答案:

答案 0 :(得分:0)

猜测我会说这一行引起了问题(你的编译器确切地告诉你哪一行是问题,这可能会包含在你的下一个问题中):

   private static int indexOfSmallest(int startIndex, Comparable[] a, int numberUsed)
   {
        Comparable min = a[startIndex];
        int indexOfMin = startIndex;
        int index;

        for(index = startIndex + 1; index < numberUsed; index++)
        {
here==========> if(a[index].compareTo(min) < 0)
                {

您正在使用InventoryItem来调用compareTo,期望Object。你可以添加一个@SuppressWarnings注释,它会让它消失:)

Comparable和Comparator的基本思想是将排序顺序应用于Object,以便标准的JDK Collections对象可以为您完成所有艰苦的工作。

在你的情况下你的comparisonTo方法做了正确的事情,但是我不确定这是好计划还是好运,所以要注意:

  1. InventoryItem.comparesTo方法需要评估当前实例到提供的实例并返回表示排序的整数,-1表示应该在参数之前排序实例(即this), 0表示它们是相同的,1表示实例在参数之后。像这样的东西让JDK为你做了所有艰苦的工作

    public int compareTo(InventoryItem i)
    {
        return Integer.valueOf(this.uniqueItemID).compareTo(i.uniqueItemID);
    }
    
  2. 为了使用Comparable你真正需要做的就是实现它,然后使用标准的JDK Collections类为你做所有繁重的工作,例如:

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class InventoryItemTest
    {
        public static void main(String [] args)
        {
    
            List<InventoryItem> items = new ArrayList<InventoryItem>();
    
            items.add(new InventoryItem("Pens", 2));
            items.add(new InventoryItem("Pencils", 3));
            items.add(new InventoryItem("Notebooks", 1));
    
            System.out.println("Before sorting");
            System.out.println(items);
    
    
            Collections.sort(items);
    
            System.out.println("After sorting");
            System.out.println(items);
        } 
    
    }
    
  3. 我意识到这可能不如编写自己的排序算法那么有趣,但如果你想在没有编译器警告的情况下这样做,那么你需要开始查看泛型