Types et classes

Toutes les données manipulées dans un programme Java sont typées statiquement. Il en est ainsi des constantes, des variables et des expressions.
En particulier, la déclaration de toute variable suppose la spécification de son type que le compilateur utilisera pour vérifier la cohérence des différentes opérations la concernant et déterminer le type des expressions limpliquant. Toutes les vérifications et le typage des expressions sont réalisées par le compilateur et donc avant toute exécution : on parle de typage statique.

La notion de type présente en Java différents aspects ;

• tout type primitif est un type 
• tout nom de classe (abstraite ou concrète) est un type ;
• si T est un type, alors T [ ] est un type (tableau sur le type T) ;
• toute interface est un type.

Les types références sont utilisés pour typer des expressions, et en particulier des variables de type référence) et permettent de désigner des objets (c'est-à-dire des instances de classes ou de tableaux). Ces types jouent un rôle analogue à celui des pointeurs, du langage C par exemple, en ce sens que les grandeurs de ces types sont des adresses en mémoire permettant d'accéder à ces grandeurs.

Les méthodes (c'est-à-dire les fonctions) sont par ailleurs elles-aussi typées et leur type prend en compte d'une part le type du résultat et le type des différents paramètres. Il peut s'avérer commode de considérer le type d'une méthode comme un type fonctionnel (au sens de langages comme CAML).

Ainsi, une fonction telles que

     T0 fonc(T1 v1, T2 v2, ..., Tn vn0 { ... }

a comme type

     T1 x T2 x ... x Tn → T0

Comme c'est le cas pour les variables, le typage des fonctions est statique. Comme nous le verrons, il s'agit là d'un point sensible en raison de la possibilité donnée par le langage

• de définir des extensions de types (notion de sous-classes) et du mécanisme d'héritage qui lui est attaché, et par là définir une hiérarchie de types autorisant des transtypages (implicites ou explicites, vers le haut ou vers le bas) ;
• de surcharger des méthodes et/ou les redéfinir dans des sous-classes.

Le typage statique des fonctions signifie que le type de la méthode qui sera invoquée lors de l'exécution est déterminé dès la compilation. Cependant, le choix de la méthode qui sera effectivement invoquée à l'exécution n'est réalisé qu'à l'exécution.
Nous aurons bien évidemment l'occasion d'y revenir.

Les variables

On retrouve tout d'abord, comme dans tout langage de programmation, la notion d'identificateur qui est une suite de longueur quelconque de lettres et chiffres Unicode, le premier caractère étant une lettre.

On peut distinguer différentes catégories de variables selon le type qui leur est associé .

Les variables de type primitif

Ce qui caractérise une telle variable, c'est que sa déclaration entraîne implicitement l'allocation de l'espace mémoire nécessaire à mémoriser une grandeur du type associé.
Ainsi, la déclaration d'une variable entière int n; alloue les 32 bits utilisés pour coder les entiers suceptibles d'être affectés à la variable n. Dans certaines circonstances (variable d'instance), une valeur par défaut sera affectée à une telle variable lors de sa définition.

   --> cat Null.java
   class Null1 {
      int a;
      int getValeur(){return a;}
   }
   class Null2{
      Null1 nl;
   }
   public class Null{
      public static void main(String arg[]){
      Null2 obj = new Null2();
      System.out.println(obj.nl);
      System.out.println(obj.nl.getValeur());
      }
   }          
   --> java Null
   null
   Exception in thread "main" java.lang.NullPointerException    
   at Null.main(null.java:12)
   -->

   --> cat NonDefini.java
   class NonDefini1{
      int a;
      int getValeur(){return a;}
   }
   public class NonDefini{
      public static void main(String arg[]){
      NonDefini1 obj;
      System.out.println(obj.getValeur());
      }
   }   
   --> javac NonDefini.java
   NonDefini.java:8: variable obj might not have been initialized    
   System.out.println(obj.getValeur());
   
   1 error
   -->

   Null1[ ] tabNull1;   
   tabNull1 = new Null1 [10] ;    

   --> cat Tableau.java
   class Tableau {
      static int[][] t = new int [3][4];
      public static void main(String [] arg){
         System.out.println(t.length);
         System.out.println(t[0].length);
         }
      }       
   --> java Tableau
   3  // un tableau [3][4] est un tableau de 3 tableaux de 4 éléments chacun   
   4  
   -->