1.7 Types et sûreté

En Java, l'importance des types provient de ce que les programmes sont eux-mêmes des collections de types, et de ce que la sécurité des applications repose largement sur des propriétés qui leur sont liées.

1.7.0.0.1 Typer les expressions

Un langage admet un typage statique s'il est possible de vérifier à la compilation la cohérence des types de toutes les expressions, et ainsi d'éliminer la possibilité d'erreurs à l'exécution dues à des opérations qui ne respecteraient pas les contraintes de type. Le typage statique est un critère de sécurité essentiel. La plupart des langages de programmation contemporains admettent un typage statique plus ou moins strict : Pascal, Ada, C, Caml, Java (mais ce n'est pas le cas de Lisp et de Prolog). Pour permettre cette vérification, tout nom de variable doit être déclaré avec son type, tout nom de fonction doit être déclaré avec le type de ses arguments et le type de son résultat. Pour certains langages, comme Caml, le type des expressions peut même être déterminé sans qu'il soit nécessaire de déclarer le type des noms ; pour la plupart des autres, comme Java, la déclaration préalable des noms est essentielle. Ces déclarations de type permettent d'une part de déterminer la quantité de mémoire nécessaire pour représenter une donnée (par exemple, un entier est représenté sur 4 octets, un flottant en double précision sur 8 octets) et d'autre part, de vérifier que les expressions sont correctement typées, et que par exemple, on n'invoque pas une fonction avec un argument numérique alors qu'elle a été déclarée avec un paramètre de type tableau.

En Java, les types des expressions sont répartis en quatre grandes catégories : les types primitifs, les types de tableaux (§ ), les classes (chap. ) et les interfaces (§ , § ) .

1.7.0.0.2 Sûreté et sous-typage

Les deux notions de typage -- des valeurs et des expressions -- ne sont pas indépendantes. En refusant d'emblée des expressions mal typées, elles permettent d'éviter certaines erreurs qui se produiraient à l'exécution. En effet, si le compilateur détermine qu'une expression a un certain type, et si cette expression est ensuite évaluée, la sûreté du typage est une propriété du langage qui assure que :

• aucune erreur due à une opération incorrecte en raison du type des données ne peut se produire à l'exécution ;
• le résultat de l'évaluation de l'expression est une valeur d'un type compatible avec le type de l'expression.

Cette dernière notion, de compatibilité des types, mérite d'être approfondie. Considérons par exemple les nombres entiers et les nombres flottants. Un mathématicien, familier de la théorie des ensembles, sachant que l'ensemble des entiers est inclus dans l'ensemble des réels, à qui l'on demande de citer un nombre réel, n'hésitera pas à répondre $12$ ; l'informaticien lui fera remarquer que $12$ est un entier et que $12.0$ est un flottant, que ces deux constantes appartiennent à des types distincts (en Java, int et double), mais acceptera cependant $12$ comme un flottant. Inversement, ni le mathématicien ni l'informaticien n'accepterait $12.3$ comme un entier. On caractérise la relation entre ces types entiers et flottants en disant que int est un sous-type de double, mais double n'est pas un sous-type de int. Cette relation, dite de sous-typage, déjà commode pour les différents types numériques, s'avère encore plus importante pour les types d'objet : pour dire, par exemple, que les rectangles sont des formes géométriques, on fera du type Rectangle un sous-type du type Forme.

La relation de sous-typage permet d'utiliser une expression d'un sous-type de $t$ dans certains contextes où une expression de type $t$ serait attendue :

• dans le membre droit d'une affectation à une variable de type $t$ ;
• comme argument d'une fonction correspondant à un paramètre de type $t$ ;
• comme expression de retour d'une fonction dont le type de retour est $t$.

Par contre, il n'est pas possible d'affecter à une variable de type $t$ une expression d'un sur-type de $t$, ou d'invoquer une fonction avec un argument dont le type est un sur-type du type du paramètre correspondant.