Les Types
Les Expression
Les fonctions basiques
Héritage
String

1. Opérateurs




Désignation	Symbole d'opérateur	utilisation spéciale et équivalence	priorité
Parenthèse	(),[]
OPERATEURS UNAIRES
Négation	!
_ arithmétique	-
_ logique	!
_ binaire	~
Incrément	++
Décrément	--
OPERATEURS BINAIRES
Opérateurs Arithmétiques	*, /, %, +, -
Opérateurs de comparaison	>, >=, <, <=, ==, !=
Opérateurs logiques	&&, ||
Opérateurs d'affectations	=, +=, -=, *=, /=, %=	i+=2; équivaut à i=i+2;
OPERATEUR TERNAIRE
Opérateur conditionnels	?:	nb= (i>5)?10:5; équivaut à if (i>5 ) nb=10; else nb=5;




2. Expressions

1. Les accolades: les blocs d'instructions

Le plus souvent les accolades sont utilisées pour réunir plusieurs instructions, le programme les interprétant comme une seul instruction ainsi à chaque endroit où est utilisé une instruction plusieurs peuvent être mise en les inscrivant entre accolades. Cela s'avère indispensable pour les expressions de conditions ou les boucles comme nous le verrons.

Exemple:

{
instruction1;
instruction2
...
}

2. Les expressions de conditions

1. if, else if, else

On peut grâce à ces clauses permettre un déroulement d'instructions en fonction de certains tests.

 

Cas général: IF (condition1) instruction; ELSE IF(condition2) instruction; //optionnelle ELSE instruction; //optionnelle

Les conditions doivent avoir une valeur booléenne, le plus souvent ce sont des comparaisons de variables.
Comme on le voit seul la première ligne est obligatoire, elle peut être associé avec n'importe laquelle des autre lignes de même les "instruction" peuvent être remplacées par un bloc d'instruction.

Exemple

                                        if (a<b)   {
                                                       nb=0;
                                                       i++;
                                                       }
                                        else nb=1;

Comme on le voit JAVA contrairement à C++ permet l'utilisation de l'instruction "else if" et élimine le problème des imbrications existant sous C++ ainsi le cas général en C++ donnerai:

IF(condition1) instruction;
ELSE    {
            IF(condition2) instruction;
            ELSE instruction;
            }

On remarque que si beaucoup de cas sont à vérifier les imbrications vont être nombreuses rendant le programme difficile à modifier ce qui n'est pas le cas en JAVA.

2. L'opérateur ternaire

Il est utilisé lorsqu'un if else serai utiliser pour déterminer une valeur

Exemple: recherche de la variable la plus grande entre a et b

 

int grand,a=2,b=5; if (a>b) grand=a; else grand=b;

donnera

int grand,a=2,b=5; grand=(a>b)?a:b;


 

cas général: ( condition ) ? valeur1 : valeur2 ; si condition vaut vrai l'expression vaudra valeur1 sinon elle vaudra valeur2




3. Switch

Permet de tester une variable par rapport à plusieurs valeurs données et selon cette valeur de dérouler certaines instructions.

 

cas général: switch(a) { case valeur1: instruction; break; case valeur2: instruction; break; case valeur3: instruction; break; default:instruction; }




3. Répétition d'une action

1. boucle while

Cas général: While (condition) instruction; ou While (condition) { instruction; ... }


Les instructions sont exécutées à condition que la condition soit vraie, tant que celle ci est vraie les instructions sont répétées en boucle.
La condition est vérifiée avant tout entré dans la boucle.
Dans ce cas les initialisations des variables utilisées dans les tests pour la condition doivent être initialisées avant l'entrée dans la boucle et leurs valeurs doivent changer dans les instructions de la boucle.



2. boucle for

   Cas général: for (initialisation; condition; modification) instruction; ou for (initialisation; condition; modification) { instruction; ... }


Comme pour la boucle while les instructions sont répétées tant que la condition vaux vraie et celle ci est testée avant tout entré dans la boucle.
Par contre les initialisations et la modification des valeurs des variables sont gérées par la boucle et non pas dans les instructions ou le code qui précède.
On remarque entre les parenthèses suivant l'instruction "for" trois parties:
_initialisation : permet de déterminer la valeur de départ de certaines variables ( ne s'exécute qu'au démarrage de la boucle ).
_condition : test d'entré dans la boucle.
_modification : gère la modification des valeurs de certaine variable après chaque passage dans la boucle.


Exemple : Ecrit 101 lignes

for (i=0; i<=100; i++) System.out.println("ligne "+i );

on remarque que la variable i est mise à zéro et qu'après chaque exécution de l'instruction on ajoute 1 à i. Quand celle ci vaudra 101 alors on sortira de la boucle.

3. do..while

   Cas général: do { instruction; ... }while (condition);

Ici l'ordre est inversé par rapport à une boucle while, ainsi on exécute une première fois les instructions puis on teste la condition.
Cette boucle est très utilisé pour traiter des données comme les fichier ou les tableaux résultats des requêtes sur les bases de données. Dans ces cas il faut récupérer la première valeur pour voir si elle corresponds au dernier élément si ça n'est pas le cas on continue ...

4. sortir ou reprendre l'exécution d'une boucle

On peut à tout moment dans une boucle soit demander à la quitter à l'aide de l'instruction "break", soit demander à recommencer un nouveau test avec "continue" sans être arrivé à la fin des instructions de la boucle.
On peut agir sur des boucles imbriqués en utilisant l'instruction sur n'importe quel niveau en nommant les boucles et en faisant suive l'instruction "break" ou "continue" du nom de la boucle sur laquelle elle agit. Pour nommer une boucle on la fait précéder de son nom et on le sépare d'elle par ":"

Exemple :

test_x : while (x <100)
	{
	while(y <100)
		{
		if (z==100) break test_x;
		}
	}

Ici on sortira des deux boucles si x est supérieur à 100 ou que y est inférieur à 100 et z est égal à 100.