L'opérateur de transtypage () (appelé également transtype) permet de convertir à un nouveau type une référence d'objet ou une donnée primitive.

Le compilateur Java transforme automatiquement un type dans un autre lorsque cela s'avère nécessaire. Le transtypage (cast en anglais) permet d'effectuer explicitement cette conversion.

(type) expression;

byte nb = 16;
int nombre = (int)nb;

Le transtypage peut être réalisé sur tous les types primitifs à l'exception du type booléen.

Néanmoins, il est possible d'être confronter à une perte d'information lorsque le type de transtypage est inférieur à celui d'origine.

class TransType {
  static int nb = 192;
  static byte nombre = (short)nb;
  public static void main(String[] args){
  System.out.println("Nombre entier = " + nb);
  System.out.println("Nombre entier court = " + nombre);
  // affiche :
// Nombre entier = 192
// Nombre entier court = -64
} }

Lorsqu'une donnée est transtypée dans un type moins large, le nombre de bits excédentaires à gauche est supprimé, engendrant une dégradation de la valeur initiale comme dans l'exemple précédent.

Bien que cela provoque une erreur pouvant être conséquente pour un programme, aucune exception n'est lancée pour avertir le programmeur de ce risque.

Par contre à l'inverse, lorsqu'un transtypage "implicite" illégal est tenté, alors une exception est lancée indiquant une incompatibilité de type.

double nb = 1.56;
int entier = nb;

Les références d'objet peuvent également être transtypés à l'intérieur d'une famille de types.

Il est possible de convertir une référence d'objet d'une certaine classe en une référence d'objet d'une autre classe seulement si les classes sont en relation par l'intermédiaire d'un héritage.

interface Inter { ... }

class Classe extends I { ... }

class Derivee extends A { ... }

Derivee obj_enfant = new Derivee();
// Conversion implicite
Classe obj_parent = (Classe)obj_enfant;
// équivaut à Classe obj_parent = obj_enfant;
Inter obj_interface = (Inter)obj_parent;
// équivaut à Inter obj_interface = obj_parent;
Inter obj_interface = (Inter)obj_enfant;
// équivaut à Inter obj_interface = obj_enfant;

// Conversion explicite
Derivee obj_enfant = (Derivee)obj_parent;
Classe obj_parent = (Classe)obj_interface;
Derivee obj_enfant = (Derivee)obj_interface;

Le transtypage de référence d'objet n'est pas permis dans toute les situations, un type parent pouvant être incompatible avec une partie de sa descendance.

class Personne { ... }
class SalariePublique extends Personne { ... }
class SalariePrivee extends Personne { ... }

SocietePrivee oPSPri = new SocietePrivee();
Personne oP = oPSPri;
// Erreur puisque oP n'est pas forcément un oPSPub
// dans ce cas il est une instance de la classe SalariePrivee

SocietePublique oPSPub = (SocietePublique)oP;

Il n'est pas permis de transtyper une donnée primitive vers une référence d'objet et réciproquement.