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

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

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

     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]); 
    } 
} 

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 = ((InventoryItem) 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; 
    } 
}

当我编译我的代码时，它会抛出错误消息“Project9.java使用未经检查或不安全的操作”。Project9.java使用未经检查或不安全的操作

当我与Xlint重新编译：未选中喜欢它建议，我得到此消息“警告：未经检查如可比

 if(a[index].compareTo(min) < 0) 
          ^

原始类型的一个成员的compareTo（T）未选中呼叫，其中T是一个类型变量：

T extends Object declared in interface Comparable

什么我需要做的/明白，所以我可以解决这个问题非常感谢

来源

2013-07-30 user2635737

请不要粘贴代码链接，而是粘贴*代码本身*。我冒昧地为你做这件事，但下次，如果你自己努力并自己做这件事，我们会很感激。 –

请注意，你看到的是一个警告，而不是一个错误。你的代码会被编译，但由于你没有使用泛型，所以会有*风险。现在，如果您还没有学习泛型，则可以忽略该警告。要么或去泛型教程，并研究它们。 –

我会如何使用泛型？我处于入门级的OOP课程，并且不承认该术语。 – user2635737

可能增加投地InventoryItem

0123？！？

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

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

来源

2013-07-30 20:50:24 MGorgon

不幸的是我仍然得到相同的错误。 – user2635737

不，仿制药专门用于*避免*需要这种铸造。 –

不要使用Comparable作为方法参数，而使用InventoryItem。

例如：

private static int indexOfSmallest(int startIndex, InventoryItem[] a, int numberUsed) 
{ 
    InventoryItem 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, InventoryItem[] a) 
{ 
    InventoryItem temp; 
    temp = a[i]; 
    a[i] = a[j]; 
    a[j] = temp; 
}

这样编译器可以做编译时类型检查，以确保您的参数是正确的类型。

来源

2013-07-30 21:10:54

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

回答

相关问题