Après avoir exploré les notions relatives aux classes et à la programmation orientée objet, il est temps à présent de nous intéresser aux opérations fondamentales que nous offre ce langage. Pour cela, nous allons momentanément mettre de côté ce que nous avons vu au précédent chapitre, pour nous concentrer sur les instructions qu'une seule ligne nous permet de réaliser.

 En Java, comme dans tout autre langage de programmation, chaque programme doit être composé d'une série d'instructions, chacune d'elle faisant référence à une action que doit mettre en oeuvre le compilateur. Pour distinguer les différentes instructions, il a été convenu d'employer le symbole point-virgule ';' comme séparateur syntaxique. Si plusieurs instructions doivent être regroupées au sein d'un même bloc (dans le cas d'une méthode par exemple), il faut alors entourer ce dernier d'accolades. Enfin, par convention et par souci de lisibilité, il est préférable de placer une instruction par ligne, de manière à pouvoir suivre d'un seul coup d'oeil le déroulement d'un programme, comme dans l'exemple suivant:

class helloWorld
{
 public static void main (String arguments[])
 {
  String texte = "Hello, World!";

  System.out.println(texte);
  System.out.println("Fin du programme...");
 }
}

 Une expression correspond à une instruction ayant pour caractéristique de produire une valeur, à laquelle on affecte le nom de "valeur de retour". Il est à noter que celle-ci n'est pas forcément de nature numérique, Java étant en mesure de gérer d'autres types tels que des chaînes de caractères, des booléens ou encore des objets.

 Les variables représentent des liens pointant vers des cases mémoires, au sein desquelles il est possible de stocker tout type de donnée durant le déroulement d'un programme. En Java, il existe trois grandes catégories de variables qui sont, par ordre croissant de portée: les variables locales, qui n'existent qu'à l'intérieur de la méthode ou du bloc au sein duquel elles ont été définies, les variables d'instance, qu'on utilise pour définir les attributs d'un objet et ne s'appliquent donc qu'à ce dernier, et enfin les variables de classe, dont la portée s'étend à une classe entière, et donc à toutes les instances de cette classe.

 A peu d'exceptions près, ces trois types de variables se déclarent de la même manière, à savoir l'annonce du type suivi du nom de la variable proprement dite, comme dans les exemples suivants:

int compteur;
boolean fin;
float mesure;

 Il est possible de raccourcir certaines déclarations en regroupant plusieurs noms de variables à la suite de l'annonce du type, afin que celles-ci soient de nature identique. C'est ce que montre la ligne suivante:

int compteur, code, nbre;

 Enfin, la valeur d'une variable peut être assignée dès sa création, en faisant suivre sa déclaration de l'opérateur d'affectation égale '=' (qu'il est d'ailleurs préférable de se représenter sous la forme d'une flèche orientée vers la gauche):

int compteur = 0; // compteur <- 0
boolean debut = true, cheatcode = false;
String nom = "Dupont", prenom = "Marcel";

 Toute variable doit être déclarée et posséder une valeur initiale avant son utilisation au sein du programme, sans quoi le compilateur refusera d'assembler celui-ci. Par convention, on place les déclarations en début de bloc, de méthode ou de définition de classe, et on affecte à celles-ci des valeurs initiales, de manière à éviter toute erreur de compilation.

 Pour ce qui est de la syntaxe, un nom de variable doit obligatoirement débuter par une lettre, un dollar '$' ou encore un caractère underscore '_'. Après ce premier caractère, il est possible de faire suivre n'importe quelle combinaison de lettres ou de chiffres. De plus, comme Java accepte le jeu de caractères Unicode, il est possible d'employer les accents, les cédilles et quantité d'autres caractères internationaux, pour peu qu'ils possèdent un numéro de caractère Unicode. Enfin, il est naturellement impossible de prendre pour nom de variable un mot-clef de Java. Pour prendre un exemple, voici quelques noms valables pouvant être affectés à des variables:

total, $répertoire_personnel, _nom, y2kbug

 En revanche, il est interdit d'employer les noms suivants:

compte#actuel // Le caractère # est interdit
3table // Le premier caractère est un chiffre
double // double est un mot-clef de Java

 Il est également essentiel de souligner que Java est sensible à la casse des caractères (alternance majuscules / minuscules). Par conséquent, la variable Compteur n'aura par exemple aucun point commun avec la variable compteur. Pour s'y retrouver, la plupart des programmeurs Java utilisent les conventions suivantes:

• La première lettre composant le nom d'une variable est une minuscule
• Lorsqu'un nom de variable est composé de plusieurs mots, chaque mot succédant au premier commence par une majuscule
• Toutes les autres lettre sont des minuscules

 Voici quelques exemples de noms de variables se conformant à ces règles:

nbre, afficherPoint, remettreCompteurAZero

 Le mot-clef final est utilisé pour déclarer des variables constantes (bonjour le paradoxe!), dont la valeur ne pourra donc être modifiée durant l'exécution du programme. Ce genre de déclaration est autorisé pour des variables d'instance ou de classe, mais n'est autorisé avec des variables locales qu'à partir de la version 1.1 de Java. Il est donc nécessaire de tenir compte de ce paramètre si l'on désire réaliser des applets qui soient portables sur tous les types de navigateurs (le standard actuel étant encore Java v1.0.2). Naturellement, il est préférable d'affecter une valeur aux variables constantes dès leur création et, de manière à bien distinguer les constantes des autres variables, on écrit le nom de celles-ci en majuscules, comme dans les exemples suivants:

final int HAUT = 0;
final int  BAS = 1;
final double PI = 3.141592654;

 Pour finir cette partie, nous allons considérer le cas particulier des variables de classe. Comme nous l'avons vu plus haut, celles-ci ont la particularité de s'appliquer à l'ensemble d'une classe: les objets ne devront alors consulter qu'une seule case mémoire pour se renseigner quant à sa valeur. Pour déclarer une variable de classe, les règles précédentes restent valables, à l'exception qu'il faut placer le mot-clef static pour faire comprendre au compilateur que sa portée s'étend à la classe toute entière. Par exemple, nous pourrions déclarer les variables de classe suivantes dans la déclaration de la classe à proprement parler:

static int compteur;
static final float PI = 3.14;

 Les types de variables peuvent être regroupés en trois classes distinctes:

• les types de données de base
• le nom d´une classe ou d´une interface telle que les chaînes de caractères
• les matrices

 La première catégorie correspond aux types permettant de stocker des entiers, des nombres réels, des booléens ou encore des caractères tels que nous les avons rencontrés jusqu´à présent. Ces types de données étant directement intégrés au langage au sein du package java.lang, on les appelle également "types primaires".

 Pour stocker des entiers, on dispose de quatres types de données dont les caractéristiques sont données par le tableau ci-dessous:

 En Java, il est possible de préciser explicitement la nature d´un littéral; par exemple, pour indiquer au compilateur qu´un littéral entier doit relever du type long, on accompagnera celui-ci de la lettre ´L´ comme suit:

long compte = 214L;

 Il est également possible de préciser des nombres dans une base autre que décimale. Ainsi, pour représenter un nombre octal (en base 8), on fera précéder sa représentation par le chiffre 0 comme le montre l´exemple suivant:

int nombreOctal = 012; // Equivalent à 10 en décimal

 Pour représenter les nombres hexadécimaux (en base 16), on devra en revanche utiliser le préfixe ´0x´:

int nombreHexadecimal = 0xa10; // Equivalent à 2560 en décimal

 Mis à part les nombres entiers, le langage est également en mesure de gérer les nombres réels, encore appelés nombres à virgule flottante. Pour cela, deux types sont mis à notre disposition:

 Les littéraux à virgule flottante utilisent le point ´.´ comme séparateur décimal. Il faut également prêter attention au fait que ceux-ci relèvent tous du type double: pour préciser qu´un littéral doit être du type float, il faut faire suivre celui-ci de la lettre ´F´ comme suit:

float mesure = 12.27F;

 Les booléens en Java ne permettent de stocker que deux types de valeurs: soit vrai (true dans le langage), soit faux (false). Ceux-ci sont introduits par le mot-clef boolean. Cependant, comme il a déjà été précisé plus haut, il est impossible de remplacer ces valeurs par les décimaux 0 et 1. En guise d´illustration, voici un exemple d´utilisation d´un littéral booléen:

boolean debut = true;

 Enfin, le dernier type primaire correspond aux caractères relatifs au standard Unicode, ce qui nous permet d´avoir accès à plusieurs milliers de symboles différents. On annonce celui-ci par le mot-clef char, et les littéraux qui s´y ramènent doivent être entourés du caractère guillemet simple ´ comme le montre la ligne suivante:

char caractereA = ´A´;

 Parfois, il peut être nécessaire d´utiliser certains types de caractères qui ne sont pas accessibles depuis le clavier, non imprimables à l´écran ou encore entrant en conflit avec les règles typographiques du langage. Pour cela, il a été convenu d´employer certains codes dont la liste est donnée ci-dessous:

 Les chaînes de caractères constituent une extension du type précédent, c'est la raison pour laquelle il sera à nouveau possible d'employer tous les caractères spéciaux décrits dans le tableau ci-dessus. Cependant, contrairement à tous les autres types de Java, les chaînes sont gérées comme des objets à part entière: c'est ce qui nous permettra d'utiliser un certain nombre de méthodes permettant de simplifier les opérations que nous devrons leur faire sûbir.

 De manière à simplifier la vie des programmeurs, il a été convenu qu'une variable de type chaîne de caractères puisse être déclarée directement comme une variable de type primaire, grâce au "mot-clef" String. Il n'est donc pas utile de créer explicitement un nouvel objet String via le mot-clef new. Enfin, les littéraux se ramenant à ce type doivent être entourés du caractère double-guillemet ", comme l'illustre l'exemple suivant:

String chaine = "\" Hello World !!! \"";

 Pour finir cette partie nous allons parler des matrices, qui présentent comme similitude vis-à-vis des chaînes de caractères le fait d'être également des objets sur lesquels nous pourrons appliquer un certain nombre de méthodes. Ce type permet de stocker un ensemble de valeurs d'un même type à l'intérieur d'un tableau, dont chaque élément pourra être accessible en fonction de son indice au sein de ce dernier. En Java, une matrice peut contenir des valeurs issues de n'importe quel type de donnée primaire, ainsi que des objets et par voie de conséquence des matrices elles-mêmes...

 La déclaration d'une variable de matrice est constituée de l'annonce du type des valeurs qu'elle contiendra, suivi du nom de la matrice à proprement parler, auquel on fait accoler une ou plusieurs paires de crochets [] en fonction de la dimension du tableau. Cependant, en fonction des goûts de chacun, il est également possible de placer les crochets à la suite de l'annonce du type, comme on peut le voir à la deuxième ligne de la série de déclarations ci-dessous:

int mesure[][];
String[] nom;

 Une fois la variable de matrice déclarée, il est nécessaire de créer un objet matrice renseignant quant au contenu et/ou la taille de la future matrice, et d'affecter celui-ci à notre variable. Pour créer une matrice vide pouvant contenir un certain nombre d'élements du type précédemment défini, il faudra employer l'opérateur new, suivi d'une nouvelle annonce du type, puis du nombre d'éléments entouré de crochets. C'est ce que l'on peut voir dans les exemples suivants:

// Liste vide pouvant contenir 3 éléments de type String
nom = new String[3];

// Tableau vide de dimensions 10x15 pouvant contenir des entiers
mesure = new int[10][15];

 Suite à ces déclarations, Java initialise chacune des cases avec la valeur par défaut correspondant au type considéré (0 pour le type int, \0 pour les caractères, false pour les booléens et enfin null pour les objets tels que les chaînes ou les matrices).

 Il est également possible de spécifier le contenu d'une matrice dès sa création en séparant chaque valeur par des virgules, et en entourant chaque ensemble par des accolades. Dans ce cas, les dimensions de la matrice seront définies par le nombre d'élements que l'on y aura placé. Il est essentiel toutefois de rappeler que tous les éléments de la matrice doivent impérativement relever du même type, comme on le voit dans l'exemple suivant:

int[][] mesure = {{1,2},{3,4}};

 Pour consulter ou affecter une valeur à une matrice, la manière de procéder sera analogue à ce que nous avons vu avec les types de base, si ce n'est qu'à présent il faudra spécifier entre crochets l'indice au sein duquel celle-ci devra être stockée. La convention au sein de Java est que tous les indices commencent par zéro, comme on peut le voir ci-dessous:

nom[0] = "Dupont";
String premierNom = nom[0];

 De façon à améliorer la lisibilité des programmes, Java met à notre disposition trois types de commentaires. Ceux-ci seront totalement exclus lors du processus de compilation, et présentent donc comme seul intérêt de pouvoir placer des informations diverses au sein du code, et ce de manière à simplifier sa compréhension.

 Le premier type de commentaire correspond au double slash // que nous avons déjà employé à maintes reprises lors des précédents chapitres. Sa caractéristique est de ne pouvoir contenir qu'une seule ligne de commentaires:

// En utilisant ce type de commentaire, on est contraint de
// réemployer le double-slash au début de chaque nouvelle ligne

 Si l'on désire faire étendre un commentaire sur plusieurs lignes, il est possible de faire précéder celui-ci par */ et le faire terminer par */. Ce type de commentaire est également très utile lorsqu'il s'agit d'éliminer momentanément des portions de code au sein du programme:

/* Le code qui suit contient une erreur encore indécelée
   et va donc être omis du programme

   String[] nom = new nom[3];
   nom[3] = "Dupond";

   A présent, laissons place à la suite du programme... */

 Enfin, le dernier type de commentaire permet d'établir une documentation officielle sur la manière dont la classe et les méthodes publiques fonctionnent; elles pourront donc être interprétées au travers de certaines applications telles que javadoc, qui a été intégrée dans le JDK de Sun. On introduit celui-ci par /**, et on fait aboutir le commentaire par */:

/** Description de la méthode ... :
    xxxxxxxxxxxx
*/

 Pour accomplir les opérations mathématiques de base, Java offre cinq opérateurs arithmétiques permettant d'effectuer une addition, une soustraction, une multiplication, une division et enfin de trouver le modulo de deux nombres (reste de la division). L'ensemble de ces opérateurs est regroupé dans le tableau suivant:

 Ces opérateurs peuvent être combinés à des affectations de manière à abbréger l'écriture de ces dernières. Pour ce faire, il suffit de faire suivre l'opérateur arithmétique du signe égal, comme dans les exemples suivants:

x += 5; // Equivaut à x = x + 5;
x %= y; // Equivaut à x = x % y;

 Il faut absolument tenir compte du fait, lors de l'utilisation de ces opérateur d'affectation abbrégés, qu'en présence d'une expression complexe, celle-ci sera évaluée en premier. Ainsi, les instructions suivantes ne seront pas équivalentes:

x -= y + 3; // Equivaut à x = x - (y + 3)
x = x - y + 3;

 Java nous offre également deux opérateurs spéciaux dédiés à l'incrémentation et à la décrémentation, qui se montrent très utiles dans le cadre d'une boucle. Chacun d'eux peut être utilisé de deux manières différentes, comme l'illustre le tableau suivant:

 y = x++;

 y = ++x;

 y = x--;

 y = --x;

 Ces opérateurs sont appelés préfixes lorsque ceux-ci sont situés avant le nom de la variable, et suffixes lorsqu'ils suivent celui-ci. Pour prendre un exemple plus parlant, nous pourrions considérer le bout de code suivant:

int x,y,z; // Déclaration de trois variables entières x, y et z
x = 3;     // x prend pour valeur 3
y = x++;   // opérateur suffixe: y prend pour valeur 3, et x reçoit la valeur 4
z = ++x;   // opérateur préfixe: x prend pour valeur 5 ainsi que z

 On peut enfin noter que l'opérateur + permet également de concaténer une chaîne de caractères avec une autre chaîne, ou même encore avec une variable d'un autre type en effectuant la conversion appropriée. C'est ce qui nous permettra notamment de faire ressortir la valeur d'une variable au cours du déroulement d'un programme:

String nom = "Java";
System.out.println("Vive " + nom + " !");

 Ce bout de programme a pour effet d'afficher à l'écran le texte: Vive Java !. On peut observer qu'à l'opposé de certains autres langages de programmation, l'opérateur de concaténation de Java n'impose pas d'espaces superflus.

 Les opérateurs de comparaison permettent de comparer deux valeurs, puis de renvoyer le résultat correspondant sous forme d'un littéral booléen. Java permet d'employer six variantes de ce type d'opérateur, qui sont données dans le tableau ci-dessous:

 ==

 !=

 <

 >

 <=

 >=

 La convention au sein de Java conçernant cette partie est identique à celle des autres langages de programmation, à savoir que l'on place les variables ou les littéraux à comparer de part et d'autre de l'opérateur de comparaison. Le code suivant montre un exemple d'utilisation de ces opérateurs:

int argent = 500000;
boolean ruine, riche;

ruine = argent <= 0;     // Dans cette expression, ruine reçoit la valeur false
riche = argent > 250000; // Ici riche reçoit la valeur true