Perché un cast in un compareTo (Object)

Question

public int compareTo(Object x) { 
    Task other = (Task)x; 

    if (other.priority == this.priority) { 
     System.out.println("Each task has the same priority level."); 
     return 0; 
    } else if (other.priority > this.priority) { 
     System.out.println(other.priority + "\n" + this.priority); 
     return -1; 
    } else { 
     System.out.println(this.priority + "\n" + other.priority); 
     return 1; 
    } 
} 

Questo è il codice che ho per un compito di programmazione per la classe. Non sono sicuro del motivo per cui utilizzo Task other = (Task)x; o cosa sta facendo qui. Il resto capisco. Se qualcuno ha una rapida spiegazione di ciò che effettivamente sta facendo qui sarei grato. Grazie!

Answer 1

si sta casting Object x a Task other - Object e Task sono diversi tipi, quindi è necessario il cast in modo da poter trattare x come tipo previsto (e ottenere alla sua campi).

Normalmente in compareTo() si dovrebbe prima avere qualcosa di simile if (x instanceof Task) prima del getto alla cieca - se non lo fai e le tipologie sono diverse poi le cose andranno in crash)

Answer 2

La firma metodo prende un oggetto Object tipo così, al fine di fare riferimento alla variabile priority all'interno dell'oggetto inoltrato, deve eseguire un cast sull'oggetto Task poiché la variabile esiste solo all'interno della classe Task.

Personalmente, però, vorrei che questo era cattiva pratica come non si sa che tipo di oggetto viene passato in (qualsiasi sottoclassi della classe Object possono essere passati in), in modo un'istanza di controllo non guasterebbe meno che si desidera eseguire un errore di runtime di ClassCastException.

In alternativa, è possibile utilizzare generics per specificare a quale tipo di oggetto si desidera confrontare. Quindi, piuttosto che fare questo ...

public class Task implements Comparable { 
    private int priority = 1; 

    @Override 
    public int compareTo(Object o) { 
     if (o instanceof Task) { 
      Task t = (Task) o; 
      return this.priority < t.priority; 
     } 

     return -1; 
    } 
} 

... si potrebbe fare questo ...

public class Task implements Comparable<Task> { 
    private int priority = 1; 

    @Override 
    public int compareTo(Task t) { 
     return this.priority < t.priority; 
    } 
}