Théorie
Transtypage : derrière ce terme un rien barbare se cache en fait l'un des fondements de la programmation Orientée-Objet (OO), la conversion de type (type casting). En clair, le transtypage permet de convertir une donnée primitive ou une référence d'objet en un nouveau type : passer un char en long, un byte en int...

Cela peut paraître superflu quand on n'en a pas l'utilité (ou que l'on vient d'un langage moins typé, comme PHP), mais le transtypage permet simplement de répondre à la question "que se passe-t-il quand les opérateurs d'une fonction sont de types différents ?". En effet, le seul moyen de les faire travailler ensemble est qu'ils aient le même type : le transtypage permet donc de donner à l'un le type de l'autre (ou vice-versa), ou même de passer les deux opérateurs dans un troisième type mieux adapté au travail à effectuer.

Du côté de Java
Les créateurs de Java ont créé un langage fortement typé mais conçu de manière intelligente : le compilateur Java prend toujours en charge, de manière automatique, la conversion d'un type à un autre lorsqu'elle s'avère nécessaire. Java suit ainsi un nombre de règles strictes lors de ces conversions, qu'il serait trop long de résumer ici. Disons simplement que le type booléen ne peut être convertit en aucun autre type, et que les types primitifs non-booléens ne peuvent être convertit implicitement qu'en un type plus grand :
byte (8 octets) -> short (16) -> int (32) -> long (64) -> float (32) -> double (64)
...et...
char (16) -> int (32) -> ...

Mais que se passe-t-il si l'on ne souhaite pas utiliser le type choisi automatiquement par le compilateur Java ? C'est là qu'entre en jeu le transtypage explicite.

Transtypage explicite
Ce transtypage permet de spécifier directement dans le code le type que l'on souhaite donner un certain type à une donnée, et donc dire au compilateur que l'on souhaite vraiment passer à ce type, au risque de perdre des données.
Définissons quelques valeurs :

double d = 5.0;
float f = 7.0;
long l = 6;
byte b = 1;

Le compilateur autorisera les transtypages suivants (implicites) :

d = f;
f = l;
l = b;
d = (f*l) + d;

mais pas ceux-là :

b = f;
l = d;
l = f + d;
...

Les valeurs sont dans un type donné, et on ne peut pas les remplacer par des valeurs d'un type "supérieur" au risque de perdre des informations. Cela étant, on voit bien qu'on ne risque pas vraiment de perdre des informations cruciales avec nos valeurs : on peut donc imposer le transtypage :

b = (byte) f;
l = (long) d;
l = (long) (f*l) + d;
...

() est l'opérateur de transtypage.
Attention : si ici nous savons que nous ne craignons rien, il peut en être tout autrement pour des valeurs moins "classiques". Quand on passe une donnée à un type moins large, Java élimine purement et simplement les bits excédentaires "à gauche", ce qui peut bien évidemment modifier la valeur de la donnée, et donc un résultat.

de byte à short : 00101101 à 0000000000101101 (aucune perte)
de short à byte : 0110101110010001 à 10010001 (pertes)

Il faut donc connaître parfaitement les valeurs que peut prendre une donnée pour savoir le transtypage que l'on peut lui appliquer.

Page 1 | 2