promozione automatica e casting

[newutente]

Sto affrontando il paragrafo sulla promozione automatica e il casting e l'esercizio appena svolto è il seguente:

Creare una classe che svolga delle operazioni aritmetiche.
In particolare la divisione tra due interi, la moltiplicazione tra un char e uno short, la somma tra un int e un float e la sottrazione tra i risultati ottenuti.
Tenere presente la promozione automatica nelle espressioni e utilizzare il casting propriamente.

la soluzione è questa:

public class Aritmetica
{
    public static void main(String args[])
    {
        int a = 5;
        int b = 3;
        double r1 = (double)(a/b); 
        System.out.println(r1);
        char c = 'a';
        short s = 5000;
        int r2 = c*s;
        System.out.println(r2);
        int i = 6;
        float f = 3.14F;
        float r3 = i+f;
        System.out.println(r3);
        double r4 = r1 - r2 - r3;
        System.out.println(r4);
    }
}

Io sinceramente credo di averci capito poco e infatti sono venuti fuori una serie di dubbi.
- perchè r1 va dichiarato come double e necessita del casting sempre a double?
- perchè la moltiplicazione tra un char e uno short può essere inserita in un int e senza usare casting?
- perchè la somma tra un int e un float può essere inserita in un float e senza usare il casting?
- perchè la differenza tra un double, un int e un float può essere inserita in un double senza usare il casting?

[andbin]

- perchè r1 va dichiarato come double e necessita del casting sempre a double?

In:
double r1 = (double)(a/b);

r1 potrebbe essere dichiarato come int, long, float o double. In tutti questi casi il cast non è affatto obbligatorio, infatti la divisione tra due int dà come risultato un int che è assegnabile a int ma anche a long/float/double tramite cast implicito (perché sono tipi più grandi di int).

- perchè la moltiplicazione tra un char e uno short può essere inserita in un int e senza usare casting?

Per gli operatori binari (ovvero con 2 operandi) vale la binary numeric promotion che, senza entrare in tutti dettagli, dice che:
- se uno dei due operandi è un double, l'altro è convertito a double
- altrimenti se uno dei due operandi è un float, l'altro è convertito a float
- altrimenti se uno dei due operandi è un long, l'altro è convertito a long
- altrimenti entrambi gli operandi sono comunque convertiti come minimo a int.

- perchè la somma tra un int e un float può essere inserita in un float e senza usare il casting?

Idem, binary numeric promotion. Se uno è int e l'altro è float, allora il int è convertito a float. E il risultato è un float.

- perchè la differenza tra un double, un int e un float può essere inserita in un double senza usare il casting?

Idem, binary numeric promotion ma applicata in 2 step.

r1 è double, r2 è int, risultato: un double. r3 è float, quindi è portato a double. Risultato finale: un double.

[newutente]

ora è tutto chiaro. grazie.

[newutente]

Mi sono venuti due dubbi.

1) Se io ho dei tipi wrapper vale lo stesso questo discorso?

- se uno dei due operandi è un double, l'altro è convertito a double
- altrimenti se uno dei due operandi è un float, l'altro è convertito a float
- altrimenti se uno dei due operandi è un long, l'altro è convertito a long
- altrimenti entrambi gli operandi sono comunque convertiti come minimo a int.

2) quando è possibile effettuare un casting tra tipi non primitivi? Ad esempio in un esercizio che ho trovato è stato possibile effettuare un cast dal tipo Annotation a Specifica (annotazione creata da me):

Specifica specifica = (Specifica) objectClass3.getAnnotation(Specifica.class);

ma perchè è stato possibile?

[andbin]

1) Se io ho dei tipi wrapper vale lo stesso questo discorso?

Sì, perché entra in gioco l'auto-unboxing (da Java 5).

Se leggi qui sul JLS: 5.6.2. Binary Numeric Promotion

vedi che il primo punto è proprio l'unboxing, se necessario. Poi, dopo, il secondo punto è la catena di regole "se uno dei due operandi è un double, l'altro è convertito a double" ecc....

2) quando è possibile effettuare un casting tra tipi non primitivi?

Ci sono un po' di regole .... potrei anche cercare di dirtele tutte (ammesso che io riesca a ricordarle tutte ). La cosa importante da tenere a mente è che un cast cambia solo la "visione" del tipo statico del reference che vede il compilatore. Non cambia nulla nell'oggetto referenziato!

Ad esempio in un esercizio che ho trovato è stato possibile effettuare un cast dal tipo Annotation a Specifica (annotazione creata da me):

Specifica specifica = (Specifica) objectClass3.getAnnotation(Specifica.class);

ma perchè è stato possibile?

Qui il cast non serve affatto!

public <A extends Annotation> A getAnnotation(Class<A> annotationClass)

L'espressione Specifica.class (un class "literal") ha come tipo Class<Specifica>. Quindi il A è preso dal compilatore come Specifica, che è sicuramente una annotazione (noti che c'è un bound? solo ciò che è-un Annotation. Se Specifica non fosse una annotation, la tua riga non compilerebbe nemmeno!).
Siccome il tipo di ritorno è A e il compilatore "sa" che è Specifica, allora è tutto type-safe. Non c'è bisogno di cast.