Note: uses unchecked or unsafe operations

[RalfiBB]

Hallo. Beim kompilieren von Listing0907.java (Guido Krüger - Handbuch der Java-Programmierung) bekomme immer ein Meldung: "Note: uses unchecked or unsafe operations". Kann mir jemand sagen, wie kann ich das beseitigen? Danke.

/* Listing0907.java */

public class Listing0907
{
	public static Object getSmallest(Comparable[] objects)
	{
		Object smallest = objects[0];
		
		for(int i = 1; i < objects.length; ++i) {
			if(objects[i].compareTo(smallest) < 0) {
				smallest = objects[i];
			}
		}
		
		return smallest;
	}
	
	public static void bubbleSort(Comparable[] objects)
	{
		boolean sorted;
		
		do {
			sorted = true;
			
			for(int i = 1; i < objects.length - 1; ++i) {
				if(objects[i].compareTo(objects[i + 1]) > 0) {
					Comparable tmp = objects[i];
					objects[i] = objects[i + 1];
					objects[i + 1] = tmp;
					sorted = false;
				}
			}
		} while(!sorted);
	}
	
	public static void main(String[] args)
	{
		// Erzeugen eines String-Arrays
		Comparable[] objects = new Comparable[4];
		objects[0] = "STRINGS";
		objects[1] = "SIND";
		objects[2] = "PAARWEIST";
		objects[3] = "VERGLEICHBAR";
		
		// Ausgeben der kleinsten Elements
		System.out.println((String)getSmallest(objects));
		System.out.println("--");
		
		// Sortieren und Ausgaben
		bubbleSort(objects);
		
		for(int i = 0; i < objects.length; ++i) {
			System.out.println((String)objects[i]);
		}
	}
	
}

 

[Joose]

1. Ist diese Meldung ein Warning -> sprich Code kompiliert, warum willst du dieses Warning unbedingt weghaben?
2. Genau deine Meldung bei Google eingetippt 1:1 -> 1.Link -> gelöst!

Warum nicht selbst zuerst bei Google geschaut? Geht doch schneller als auf eine Antwort warten

 

[Flown]

Also Java richtig verwenden, dann bekommt man auch keine Warnings. Beim sortieren ist ein Fehler: Arrays starten bei 0.
Richtig:

Spoiler: Code

public class Listing0907 {

  public static <T extends Comparable<? super T>> T getSmallest(T[] objects) {
    T smallest = objects[0];

    for (int i = 1; i < objects.length; i++) {
      if (objects[i].compareTo(smallest) < 0) {
        smallest = objects[i];
      }
    }

    return smallest;
  }

  public static <T extends Comparable<? super T>> void bubbleSort(T[] objects) {
    boolean sorted;

    do {
      sorted = true;

      for (int i = 0; i < objects.length - 1; i++) {
        if (objects[i].compareTo(objects[i + 1]) > 0) {
          T tmp = objects[i];
          objects[i] = objects[i + 1];
          objects[i + 1] = tmp;
          sorted = false;
        }
      }
    }
    while (!sorted);
  }

  public static void main(String[] args) {
    // Erzeugen eines String-Arrays
    String[] objects = { "STRINGS", "SIND", "PAARWEISE", "VERGLEICHBAR" };

    // Ausgeben der kleinsten Elements
    System.out.println(getSmallest(objects));
    System.out.println("--");

    // Sortieren und Ausgaben
    bubbleSort(objects);

    for (String s : objects) {
      System.out.println(s);
    }
  }
}

 

[RalfiBB]

public static <T extends Comparable<? super T>> T getSmallest(T[] objects) {

Das ist für mich reine Wahnsinn. Muss man wirklich jedes mal so schreiben? Verstehe nicht, warum im Buch das nicht erläutert wird. Und übrigens, die Methode getSmallest gibt "PAARWEISE" statt "SIND" zurück. Original Beispiel kann man hier ansehen.

 

[Flown]

Das ist es ja du musst es nicht jedes mal neu schreiben!

Nachdem die Methode static ist wird der Parameter T vor dem Rückgabewert (was auch wieder T ist) definiert.

<T extends Comparable<? super T>>

heißt nichts anderes, dass T ein Subtyp oder ein Typ von Comparable sein kann.
Da

Comparable<? super T>

selbst typisiert ist, wird mit dem Wildcardoperator (?) irgendeine Superklasse von T oder T selbst genannt. Somit ist sichergestellt, dass diese Methode von allen Implementierungen von Comparable mit dem T Operand als maximale Ableitung von Comparable<? super T> aufgerufen werden kann.

Spoiler: Code

package warnings;

public class Listing0907 {
  public static <T extends Comparable<? super T>> T getSmallest(T[] objects) {
    T smallest = objects[0];
    for (int i = 1; i < objects.length; i++) {
      if (objects[i].compareTo(smallest) < 0) {
        smallest = objects[i];
      }
    }
    return smallest;
  }

  public static <T extends Comparable<? super T>> void bubbleSort(T[] objects) {
    boolean sorted;
    do {
      sorted = true;
      for (int i = 0; i < objects.length - 1; ++i) {
        if (objects[i].compareTo(objects[i + 1]) > 0) {
          T tmp = objects[i];
          objects[i] = objects[i + 1];
          objects[i + 1] = tmp;
          sorted = false;
        }
      }
    }
    while (!sorted);
  }

  public static <T extends Comparable<? super T>> void test(T[] array) {
    System.out.println(getSmallest(array));
    System.out.println("--");
    bubbleSort(array);
    for (T t : array) {
      System.out.println(t);
    }
  }

  public static void main(String[] args) {
    String[] objects = { "STRINGS", "SIND", "PAARWEISE", "VERGLEICHBAR" };
    test(objects);

    Integer[] integers = { 1, 5, -1, -3 };
    test(integers);
  }
}

So um das zu verdeutlichen wie das mit Generizität funktioniert.

(PS: "PAARWEISE" ist lexikalisch kleiner als "SIND" - er gibt dir schon das richtige zurück)