Programmation Java/Transtypage
Le transtypage (ou "cast") est la conversion d'une expression d'un certain type en une expression d'un autre type. 
Transtypage implicite.
On peut affecter à un champ ou une variable d'un type donné une expression de type moins élevé dans la hiérarchie des types. De même, une méthode ou un constructeur attendant un argument d'un type donné peut recevoir en argument effectif une expression de type moins élevé que celui indiqué dans sa déclaration. L'expression fournie sera dans ce cas automatiquement convertie en le type attendu, sans que l'utilisateur ait besoin d'expliciter cette conversion. Toute tentative de conversion implicite d'un type vers un type qui n'est pas plus haut dans la hiérarchie des types déclenchera une erreur au moins à l'exécution, ou dès la compilation si elle est détectable statiquement.
Cas des types primitifs.
Dans le cas des types primitifs, la hiérarchie est la suivante : byte est plus bas que short, short plus bas que int, char plus bas que int, int plus bas que long, long plus bas que float, float plus bas que double. Le type boolean est incomparable avec les autres types de base. On peut par exemple assigner à une variable de type float une expression de type int égale à 3 : l'expression 3 sera, avant affectation, convertie en float (3.0). Cette forme de conversion est réversible : on peut, après passage de int à float, reconvertir l'expression de type float résultante en int par une conversion explicite (voir ci-dessous) et retrouver la même valeur. 
int n;
float f;
n = 3;
f = n; // 3 est converti en 3.0
Le type déterminé statiquement pour les arguments d'opérateurs arithmétiques est le premier type à partir de int dans lequel peuvent être convertis les types de tous les arguments. Les expressions constantes 
sont d'autre part typées statiquement en le premier type à partir de int permettant leur représentation.
short s;
s = 15; // <-- erreur générée, 15 est typé statiquement de type int
 // s = (short) 15; fonctionne (conversion explicite)
s = s + s ; // <-- erreur générée, chaque sous-expression est convertie en int
 // et l'expression s + s est typée de type int. 
 // s = (short) (s + s) fonctionne
int n;
long l = 10L;
n = s; // correct : conversion implicite
n = n + l; // <-- erreur générée, la sous-expression gauche est convertie en long
Typage par suffixe.
Par défaut les entiers sont typés en codice_1 mais un suffixe peut les spécifier codice_2 :
class Suffixes
 public static void main(String[] args)
 Object n = 1;
 System.out.println(n.getClass()); // Integer
 n = 1L;
 System.out.println(n.getClass()); // Long
 n = 1.1;
 System.out.println(n.getClass()); // Double
 n = 1.1F;
 System.out.println(n.getClass()); // Float
Cas des types références.
La "classe" d'un objet ne peut évidemment être convertie : durant toute sa durée de vie, il s'agit toujours de la classe dans laquelle est défini le constructeur employé lors de sa création. Le "type d'une référence" peut en revanche être converti selon les règles suivantes :
Dans l'exemple ci-dessous, on fait pointer trois références a, i, j, b, c vers un même objet de classe C :
class A { ... } 
class B extends A implements I { ... } // implémente I, descendante de A
class C extends B implements J { ... } // implémente I et J, descendante de A et B