[JAVA] Polimorfismo e Interfacce

[ragnonerodocet]

Di seguito posto il codice che mi ha annichilito...

public interface PricedItem {  
   public void setPrice(double price);  
   public double getPrice();  
} 

L'interfaccia PricedItem definisce il comportamento di un articolo con prezzo. Possiamo a questo punto implementare l'interfaccia in una classe applicativa Book nel modo seguente  

  public class Book implements PricedItem {  
        private String title;  
        private String author;  
        private double price;  
        ...  
        public void setPrice(double price) {  
            this.price = price;  
        }  

        public double getPrice() {  
            return price;  
        }  
    }  



Il codice client che necessita del prezzo di un libro può quindi essere scritto così:  

    double computeTotalPrice(Collection items) {  
        Iterator it = items.iterator();  
        PricedItem item;  
        double total = 0;  

        while (it.hasNext()) {  
            item = (PricedItem)it.next();  
            total += item.getPrice();  
        }  
        return total;  
    }

La mia domanda e' questa:

nella riga

total += item.getPrice();

come diamine faccio a chiamare un metodo di un'interfaccia???

devo effettuare certamente un casting, dato che il metodo next() della classe Iterator restituisce un Object, ma com'e' possibile che a run time la JVM si accorga del reale tipo dell'oggetto se il metodo e' eseguito su una variabile di tipo PricedItem???

[andbin]

Originariamente inviato da ragnonerodocet
devo effettuare certamente un casting, dato che il metodo next() della classe Iterator restituisce un Object, ma com'e' possibile che a run time la JVM si accorga del reale tipo dell'oggetto se il metodo e' eseguito su una variabile di tipo PricedItem???

No alt. Ogni oggetto a runtime mantiene una informazione precisa e completa sul suo tipo (a parte i tipi parametrici dei generics, per via della "erasure" ... ma è un altro discorso).

next() ha come tipo statico di ritorno un Object ... non vuol dire che l'oggetto restituito è davvero di tipo Object. Sicuramente "è-un" Object, cioè deriva da Object.

Nella riga:

item = (PricedItem)it.next();

c'è un "down-cast" che è quindi soggetto ad un controllo a runtime da parte della JVM.

Se l'oggetto restituito da next() è realmente un Book, allora la JVM "sa" che è un PricedItem, quindi il cast ha successo. Se l'oggetto non è un PricedItem, allora la JVM lancia ClassCastException.