Operatori di cast in Java

Gli operatori di cast in Java ti permettono di forzare i dati a essere qualcosa che non sono.

Che cos'è il casting? Il casting ti permette di prendere un dato di un tipo e trasformarlo in un altro. Ora, non sempre è sicuro farlo, e Java te lo farà notare se provi a forzare qualcosa che non va.

In Java ci sono due principali tipi di casting:

• Casting implicito (automatico): quando Java può fare il casting per te senza che tu lo chieda.
• Casting esplicito (manuale): quando devi dire chiaramente a Java che vuoi fare il casting, anche se lui potrebbe avere dubbi.

Java fa il casting in modo implicito quando è sicuro di poterlo fare senza perdere dati, ma ti obbliga a farlo in modo esplicito quando c'è il rischio di tagliare o perdere informazioni.

Oltre ai tipi primitivi (come `int`, `double`, `float`, ecc.), il casting può essere fatto anche con gli oggetti. Qui la cosa si fa più interessante, e anche un po’ più complicata.

Vediamo insieme tre esempi per capire come funziona il casting nelle varie situazioni.

Esempio di casting implicito 

Se hai una variabile di tipo `int` (che occupa meno spazio in memoria) e la vuoi mettere in una variabile di tipo `double` (che occupa più spazio), Java lo fa tranquillamente:

int numero = 5;
double piuGrande = numero; // Questo è un cast implicito.
System.out.println(piuGrande);

Stampa: 5.0

Perché funziona? Perché un `double` può contenere tranquillamente un `int`.

È come mettere un calzino piccolo in un cassetto grande. Java non si lamenta, anzi, lo fa volentieri!

Esempio di casting esplicito

Ora, proviamo a fare il contrario: hai un `double` e vuoi metterlo in un `int`.

Qui la situazione è diversa, perché un `double` può contenere valori decimali, mentre un `int` no.

Devi quindi dirlo chiaramente a Java: "Sì, so che potrebbe essere pericoloso, ma voglio farlo lo stesso!"

double numeroGrande = 5.75;
int numeroPiccolo = (int) numeroGrande; // Questo è un cast esplicito.
System.out.println(numeroPiccolo);

5

Che è successo? Il numero 5.75 è stato "tagliato" ovvero il decimale è stato semplicemente eliminato.

Java non arrotonda, è spietato: prende solo la parte intera. Quindi, da 5.75, ottieni 5.

Casting con oggetti

Immagina di avere una classe `Animale` e una sottoclasse `Cane`.

Ora, un cane è un animale, quindi puoi dire che un oggetto di tipo `Cane` può essere trattato come un oggetto di tipo `Animale`. Questo è un esempio di polimorfismo in Java.

Tuttavia, se hai un oggetto di tipo `Animale`, non puoi semplicemente trattarlo come un `Cane`... a meno che non sia effettivamente un cane!

Ecco un esempio pratico.

class Animale {
    public void faiSuono() {
        System.out.println("Un animale fa un suono...");
    }
}

class Cane extends Animale {
    public void faiSuono() {
        System.out.println("Il cane abbaia!");
    }

    public void scodinzola() {
        System.out.println("Il cane scodinzola.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animale mioAnimale = new Cane();  // Un cane è un animale.
        mioAnimale.faiSuono();  // Stampa: "Il cane abbaia!"

        // Casting esplicito
        Cane mioCane = (Cane) mioAnimale;  // Ora mioAnimale è trattato come un Cane.
        mioCane.scodinzola();  // Stampa: "Il cane scodinzola."
    }
}

In questo esempio, il cane è trattato prima come un `Animale` e poi, con il casting esplicito, come un `Cane` vero e proprio, con tutte le sue caratteristiche (come scodinzolare!).

Il cane abbaia!
Il cane scodinzola.

Ma attenzione: se provi a fare il cast di un oggetto che non è effettivamente del tipo che vuoi ottenere, Java ti darà un bel errore a runtime!

Animale mioAnimale = new Animale();
Cane mioCane = (Cane) mioAnimale;

Exception in thread "main" java.lang.ClassCastException: class Animale cannot be cast to class Cane

Perché non va? Perché stai cercando di far passare un semplice animale per un cane, ma quel particolare animale non ha le caratteristiche del cane. Non ha imparato a scodinzolare!

In conclusione, gli operatori di cast in Java ti permettono di "forzare" un tipo di dato a essere trattato come un altro, sia con i tipi primitivi che con gli oggetti.