Java les structures syntaxiques élémentaires

Cours Java introduction structures syntaxiques élémentaires, tutoriel & guide de travaux pratiques JAVA en pdf.

Structures syntaxiques élémentaires

• Types de base : 6 types numériques, un type booléen, un type alphabétique, et une classe chaîne

o byte (entier compris entre –128 et 127)
o short (entier -32768 et 32767)
o int (entier entre –2.147.483.648 et 2.147.483.647)
o long (entier entre -9.223.372.036.854.775.808 et 9.223.372.036.854.775.807)
o float (réel entre -3,410-38 à 3,41038)
o double (réel double précision entre -1,710-308 et 1,710308)
o boolean (booléen valant true ou false)
o char (caractère alphabétique dont la valeur est mise entre apostrophes)
o String (chaîne de caractères, à valeur entre guillemets) seul type non primitif

• Variables :

o Syntaxe : type_de_donnée nom_de_la variable; o Exemples : byte b;
short s; long l; float f; // Plusieurs variables de types différents
double d, e, f; // Plusieurs variables de type identique
int i = 10; double g = 1.2e3; // Déclarations et initialisations
char c = ©\n©, d =©\u0082©; // Quelques caractères d’échappement
String titre = « Java »; // Objet chaîne de caractères

• Affectation :

o Syntaxe : nom_de_la_donnée = valeur;
o Exemples : x = 2 ; a = true ; c = « algorithmique » ;
• Opérateurs élémentaires : arithmétiques, logiques, et sur chaîne
o Opérateurs arithmétiques : +, -, *, /
o Opérateurs de comparaison : <, >, ==, !=, >=, <=, && (Et logique), || (Ou logique)
o Opérateurs sur chaînes : +, .length, [ ]

• Expressions : combinaisons de valeurs, de variables, et d’opérateursQuelques exemples : x + 2, i
< j, (x +3) * (y – 5) / (x + y)Règles de priorité standards sur les opérateurs, utilisation conseillée des parenthèses
o Chaînage possible dans certains cas : x = y = z = 3 ;
o Expressions abrégées : x +=2 ; // x = x + 2
i /= (j+3) ; // Attention à l’expression incomplète: i /= j + 3
o Expressions condensées : // Supposons que x = 2 ;
x++ ; // x vaut 3
++x ; // x vaut 4
y = x++ ; // y vaut 4, puis x vaut 5
y = ++x ; // x vaut 6, puis y vaut 6
// Mêmes constats pour l’opérateur de décrémentation —

• Bloc : définit l’espace de visibilité pour un ensemble de données o Syntaxe : { }
o Imbricable, et utilisable partout où une instruction est utilisable ; les variables déclarées dans
un bloc cessent d’exister en dehors du bloc
o Exemple : int i = 4 ; int j = 2 ;
{
int j = 3 ; // nouvelle variable j
int y = i + j ; // y vaut 7 (= 4 + 3)
{
int i = 2, y = 0 ; // Nouvelles variables i et y
int j = y – i ; // j vaut –2 (= 0 – 2)
}
j = j + i – y ; // j vaut 0 (= 3 + 4 – 7)
}
int x = i + j ; // x vaut 6 (= 4 + 2)
// Ici, y n’existe pas

Alternatives

• Test unaire
o Syntaxe: if (condition) instruction ou bloc
o Exemples: if (y > x) max = y ;
if ((n > 0) && (m >0)) { n *= m ; m– ;}
• Test binaire
o Syntaxe: if (condition) instruction ou bloc
else instruction ou bloc
o Exemple: if (y > x) max = y;
else max = x ;
o Imbrications : if (x > y) {
if (x > z) max = x ;
else max = z;
}
else {
if (y > z) max = y; else max = z;
}
o Condensé : (condition) ? valeur_1 : valeur_2 ;
o Exemples : z = (x > y) ? x :y ;
s = (((u > v) ? u :v) > w) ? ((u > v) ? u :v):w;
• Test n-aire
o Syntaxe: switch (variable_scalaire) {
case valeur_1 : suite d’instructions ou/et de blocs
case valeur_2 : suite d’instructions ou/et de blocs

case valeur_n : suite d’instructions ou/et de blocs
default : suite d’instructions ou/et de blocs (cette dernière clause est optionnelle)
}
o Exemple: switch (operation) {
case ©+©: za = xa+ya; zb = xb+yb; break ;
case ©-©: za = xa-ya; zb = xb-yb; break ;
case ©*©: za = (xa*ya)-(xb*yb); zb = (xb*ya)+(xa*yb); break
case ©/©: { double m = ((ya*ya)+(yb*yb)) ;
za = ((xa*ya)+(xb*yb))/m; zb = ((xb*ya)+(xa*yb))/m;
}
break ;
default : za =zb = 0 ;
}
o Remarque : sans l’instruction break entre deux « case » consécutifs, l’exécution du premier d’entre eux, se poursuit par l’exécution du second.

LIRE AUSSI :  Course a comparison of bug finding tools for Java

Répétitions

• Nombre indéterminé d’itérations, avec test initial
o Syntaxe: while (condition) instruction ou bloc
o Exemple: fact =1;
while (n > 0) fact*=n–;
• Variante avec test final
o Syntaxe: do instruction ou bloc while (condition) ;
o Exemple: fact =1;
do fact*=n– while (n > 0); // si au départ n < 0 on a fact = n
• Nombre déterminé d’itérations
o Syntaxe: for (initialisation ;test_d_arrêt ;incrément) instruction ou bloc o Exemple: fact =1;
for (int i = 1; i < n; i++) fact*=i;
o Remarque: il est possible d’avoir plusieurs initialisations, et/ou plusieurs incréments
o Exemple : for (i = 0, j = n ; i < j; i++, j–) { /* Des instructions ici */
}
• Boucles infinies: for (i = 0 ;;i++) {
// Boucle infinie par absence de test (sortie par break)
}
for ( ;;) {
// Boucle infinie par excellence
}
for (i = 0 ; i < n;) {
// Boucle infinie par absence d’incrément
}
while (true) {
// Boucle infinie couramment utilisée
}
• Etiquette et rupture : infinie : while (true) { do {
if (n < 0) break ; // Sortie du do…while
if (m > 0) break infinie; // Sortie du while
} while (true)
}

Tableaux

• Tableau unidimensionnel
o Syntaxe: nom_du_type_de_base[] nom_de_la_variable_tableau ;
o Exemple: int[] liste;
o Autre syntaxe : nom_du_type_de_base nom_de_la_variable_tableau[] ;
o Exemple: int liste[];
o Création :nom_de_la_variable_tableau = new nom_du_type_de_base[dimension]
o Exemple: liste = new int[100]; // Les indices commencent toujours à 0
o Accès : nom_de_la_variable_tableau[indice]
o Exemple: (for i = 0 ; i < 100 ; i++) {
s+= liste[i];
liste[i] = 0;
}

1. Structure d’un programme
2. Compilation et exécution
3. Environnement de programmation
4. Structures syntaxiques élémentaires
5. Alternatives
6. Répétitions
7. Fonctions
8. Exceptions
9. Tableaux
10. Packages et importation
11. Entrées – Sorties standards
12. Travaux pratiques

structures syntaxiques élémentairesTélécharger le cours complet

Télécharger aussi :

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *