Le langage

1.1 Les types de base

1.1.1. Les identificateurs

A chaque objet, variable, programme, on associe un nom.
Sont admis tous les caractères alphanumériques, le signe souligné _ et le caractère $. Le premier caractère d’un identificateur ne peut pas être un chiffre.

JAVA est sensible à la casse des lettres.

Un identificateur ne doit pas appartenir à la liste des mots réservés du langage.

1.1.2. Commentaires

Trois possibilités de délimiter les commentaires existent :
Le symbole // : ce qui suit ce symbole dans la ligne est considéré comme commentaire.
Les symboles /* et */ : ce qui est entre les symboles est considéré comme commentaire.
Les symboles /** et */ qui permettent avec un utilitaire de SUN de générer des commentaires au format html.

1.1.3. Variables

En JAVA, il faut déclarer toute les variables en précisant leur type. On peut éventuellement ajouter des modificateurs. Ainsi déclarer une variable « final » revient à créer une constante car le compilateur refusera toutes les instructions modifiant la valeur de cette variable.
On peut effectuer une affectation ou assignation (donner une valeur) en déclarant une variable.
Lors de sa création une variable reçoit toujours une valeur par défaut. (0 pour les entiers, 0.0 pour les flottants, false pour les booléens, null pour les objets).

Le signe égal ( = ) est le symbole d'assignation.

Le point virgule ( ; ) est le terminateur d'instruction.

int i;
double a,b,c;
final float PI = 3.14159f;

1.1.4. Les littéraux

Les littéraux définissent les valeurs qui sont utilisées par les programmes. Il en existe trois catégories les booléens, les nombres et les caractères.

1.1.4.1 Booléens

Deux valeurs possibles true (vrai) et false (faux).

1.1.4.2 Entiers

Il est possible d’exprimer les entiers en décimal, octal et hexadécimal.

int i = 10 ;     //format décimal
int i = 010;     //format octal : le nombre commence par un zéro.
int i = 0x10;    /*format hexadécimal : le nombre commence par un zéro suivi d’un x (majuscule ou minuscule)*/
long k = 123L    //forçage au type long par ajout d’un L (ou l) à la fin.

Il en existe 4 types qui différent par la taille : byte (1 octet), short (2 octets), int (4 octets), long (8 octets).

Attention aux débordements :
short i = 20000,j=20000,k ;  //k = i+j vaut –25536 !

Sur les 16 bits du type short, le bit de poids fort est le bit de signe et les 15 bits restants contiennent la valeur.

1.1.4.3 Flottants

Deux types de flottants existent : simple précision (float) ou double précision (double).
Diverses écritures sont possibles :
float x = 10.0f; // nombre suivi par F ou f (obligatoire)
double z = 1.0d; // nombre suivi par D ou d (facultatif)
double y = -1E-5,t=8.4E5,h=.25;

1.1.4.4 Caractères

La représentation d’un caractère est un caractère placé entre deux apostrophes ( ' ). Les caractères de JAVA respectent le codage « Unicode » sur 2 octets.

char x = ‘x’;
char omega = (char)969 ;//affiche le caractère grec oméga w.

Tableau des types de JAVA

1.1.4.5 Chaînes de caractères

Les chaînes de caractères sont formées par une succession de caractères entourés par des guillemets ("). Elles correspondent au type String qui est une classe à part entière dotée de constructeurs et de méthodes spécifiques.

String s = “ceci est une chaîne”;

1.1.5. Les tableaux

1.1.5.1 Tableaux simples

Les tableaux sont déclarés en post-fixant soit le type des variables du tableau soit le nom de celui-ci avec des crochets.

int i[];
int[] i;

Ce genre de déclarations est insuffisant pour pouvoir utiliser le tableau.

Il est nécessaire de préciser sa dimension (pour que le compilateur réserve la mémoire nécessaire)

Ceci est réalisé au moyen de l’instruction new.

int i[] = new int[10];

Cette instruction crée un tableau de 10 entiers dont les indices vont de 0 à 9.
Il est aussi possible d’initialiser un tableau lors de sa création :

int impairs[] = {1,3,5,7,9,11}; //tableau à 6 éléments.
int x = impairs[2] ;            // x = 5

Le séparateur des valeurs est la virgule.

1.1.5.2 Tableaux multidimensionnels

La syntaxe est la même que pour les tableaux à une dimension :

int tab[][] = new int[4][3]; //indices 0, 1, 2, 3 et 0, 1, 2
float mat[][] = new float[3][3];

Comme pour les tableaux à une dimension, Il est possible d’initialiser un tableau lors de sa création :

int carre = {{11,12,13},{21,22,23},{31,32,33}};
int x =carre[1][2] ;                  //x = 23

Dans un bloc de valeurs, le séparateur est la virgule. Les blocs sont séparés par des virgules

1.1.6. Portée des variables

1.1.6.1 Blocs d’instructions.

Un bloc est un ensemble d'instructions contenues entre deux accolades { }

Il est possible d’imbriquer des blocs.

1.1.6.2 Portée des variables

L’emplacement de la déclaration de la variable définit sa zone de visibilité.
Une variable est visible dans le bloc dans lequel elle est définie.

class test{   //début du bloc test
    int k=5;
    void methode1()
    {   // début de methode1
     float x=4;
     ...
    } //fin de methode1.

    void methode2()
    {   // début de methode2
     double z;
     int k=8;
     ...
    } //fin de methode2.

    void methode3()
    {   // début de methode3
     double y;
     ...
    } //fin de methode3.
}  //fin de test

Dans le programme ci-dessus, la variable x n’est visible que dans methode1. La variable z n’est visible que dans methode2.

Par contre k est visible dans methode1 et methode3 avec la valeur 5. Mais dans methode2 l’affectation int k = 8 masque la variable k définie dans test. Dans le bloc methode2, la valeur initiale de k est 8.

1.1.7 Arguments des méthodes

Quand l'argument est un type primitif on fait un passage par valeur : c'est la valeur de l'argument qui est transmise à la méthode. Si celle-ci modifie cette valeur la modification n'est pas répercutée sur la variable initiale.
Par contre si l'argument est un objet ou un tableau on fait un passage par adresse : c'est l'adresse de l'objet ou du tableau qui est transmise. Toute modification causée par la méthode est répercutée.

1.1.8 Conversions de types

Les conversions de type doivent être faites explicitement en JAVA.

On encadre l’identificateur du type désiré par des parenthèses ( ).

char c;   double d;   int i=64;
c = (char)i; //conversion de la valeur de i en caractère
i = (int) d ; //effectue la troncature de d 

Les conversions de type peuvent entraîner des pertes de précision.

Par exemple à la suite de l’instruction char c = (char)64.5f; c est égal à @

1.2. Les opérateurs

1.2.1 Opérateurs numériques

Ils sont classés selon le nombre d’arguments nécessaires en opérateurs unaires et binaires.

1.2.1.1 Opérateurs unaires

1.2.1.2 Opérateurs binaires

1.2.2 Opérateurs relationnels

Noter la différence entre l'assignation ( = ) et l'égalité ( = = ).

1.2.3 Opérateurs logiques

Si on utilise les opérateurs évalués && et ||, l’évaluation de l’expression cesse dès qu’une certitude est acquise (premier terme false dans un &&, ou premier terme true dans un || ).

1.2.4 Opérateurs de manipulation des binaires

Ces opérations de manipulation sur les binaires correspondent à des opérations arithmétiques sur des entiers.

~i;      => (i – 1) -1
i >> k  => i / (2^k) si i>0
i << k    => i * (2^k)

1.2.5 Précédence des opérateurs

Dans le tableau les opérations sont classées par ordre de priorité.

Il est toujours possible de modifier cet ordre en utilisant des parenthèses.

    Retour au menu