Par conventions, on écrit les variables en camelcase (exemple : maVariablePreferee) et les constantes en majuscule avec underscore (exemple : static final int MA_CONSTANTE = 1).
Les types primitifs sont :
| Type | Commentaires |
|---|---|
| byte | Entier signé sur 1 octet |
| short | Entier signé sur 2 octets |
| int | Entier signé sur 4 octets |
| long | Entier signé sur 8 octets |
| float | Flotant simple précision (4 octets) |
| double | Flotant double précision (8 octets) |
| boolean | true / false |
| char | Caractère unicode sur 2 octets (UTF-16) de '\u0000' à '\uffff' |
Les litéraux sont :
boolean b = true; int i = 0; long l = 0L; float f = 0.0f; double d = 0.0d; char c = '\u0000'; String str = "Hello";
Les notations spéciales :
int n = 0x1a; // Notation hexadecimale : int n = 0b110110; // Notation binaire : double d = 8.91e3; // Notation scientifique : # Les séquences d'echappement : String s = "\b"; // backspace String s = "\t"; // tab String s = "\n\r"; // linefeed cariage return String s = "\f"; // form feed String s = "\\"; // back slash
Les "_" dans les literaux numériques depuis Java 7 :
long n = 234_393_211_947_333L; double pi = 3.141_592d; int m = 0b101101011_01000101_10001001;
Restrictions : pas de "_" collé à "f" ou "d" ou "L" ou "x" ou "b", pas de "_" en début ou fin de litéral.
Un tableau est un container d'objets de même type.
Sa taille est fixé à sa création.
On parle de tableau indexé car l'accès aux éléments se fait par un index allant de 0 à N-1.
Example :
int[] myArray; int[] otherArray; int i; myArray = new int[10]; otherArray = { 100, 200, 300, 400 }; for (i=0; i<myArray.length; i++) { System.out.println("myArray["+i+"] = "+myArray[i]); }
Un tableau peut être multi dimensionnel :
int[][] board; board = new int[8][8];
Copier un tableau dans un autre avec la méthode System.arraycopy :
System.arraycopy(mySourceArray, fromPos, myDestArray, toPos, elementsCount);
Méthodes utiles dans la classe java.util.Arrays :
int[] myArray;
int pos, from, to;
int[] newArray;
boolean isEqual;
myArray = { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
// Tri
java.util.Arrays.sort(myArray);
// Recherche
pos = java.util.Arrays.binarySearch(myArray, 100);
// Portion d'un tableau
from = 2;
to = 10;
newArray = java.util.Arrays.copyOfRange(myArray, from, to);
// Comparaison
isEqual = java.util.Arrays.equals(myArray, anotherArray);
// Initialisation de tous les éléments
java.util.Arrays.fill(myArray, -1);
// Affichage sous forme de chaine
// Affiche : "[ 10, 20, 30, 40, 50, 60, 70, 80, 90 ]"
System.out.println(java.util.Arrays.toString(myArray));
| Operateur | Description |
|---|---|
|
Assignation |
|
Addition ultiplication Division Modulo |
|
Incrementation et Décrémentation |
|
NOT |
|
Comparaison |
|
AND OR |
|
détermine si un objet est une instance d'une classe ou d'une interface |
|
AND bit a bit, OR bit a bit, exclusive OR bit a bit |
|
Shift bit a bit à geuche, à droite |
|
Unsigned Right shift |
|
Expression conditionnelle |
Cas particulier de == et equals :
// Comparaison si deux objets ont la meme reference : if (obj1 == obj2) { ... } // Comparaison si deux chaines de caracteres ont la meme sequence de caracteres : if (str1.equals(str2)) { ... }
Une expression est constituée de variables, d'opérateurs, de parenthèse. Elle retourne une valeur.
Une instruction (statement) se termine par un point-virgule. On distingue les "expression statement" :
Un bloc est un ensemble de une ou plusieurs instructions regroupées dans des acolades (braces en anglais).
// -------------------- // CONTROL FLOW : if // -------------------- if (expression) { // instructions } else { // instruction } // -------------------- // CONTROL FLOW : switch // -------------------- // Fonctionne avec byte, short, int, char, Byte, Short, Integer, String dayOfWeek = "Monday"; switch(dayOfWeek) { case "Saturday": // instructions break; case "Sunday": // instructions break; default: //instructions break; } // -------------------- // CONTROL FLOW : for // -------------------- for (i=0; i<MAX; i++) { // instructions } // -------------------- // CONTROL FLOW : while // -------------------- i = 0; while (i<MAX) { // instruction i++; } // -------------------- // CONTROL FLOW : do while // -------------------- i=0; do { // instructions i++; } while (i<MAX); :
L'instruction break : elle permet de sortir de la boucle "switch", "for", "while" ou "do-while" la plus proche. Un break peut etre labellisé pour dire quelle est la boucle concernée.
L'instruction continue : elle permet de passer à l'itération suivant dans un "for", "while" ou "do-while". Un continue peut etre labellisé pour dire quelle boucle passer.
L'instruction return : termine une méthode. Peut renvoyer une valeur si la méthode n'est pas de type void.
// -------------------- // break avec label // -------------------- search: for (i=0; i<MAX; i++) { for (j=0; j<MAX; j++) { if (expression) { break search; } } } // -------------------- // continue avec label // -------------------- search: for (i=0; i<MAX; i++) { while (expression) { if (expression) continue search; // instructions } // instructions } // -------------------- // return // -------------------- public void myFunction(int p) { // instructions if (expression) return; // instructions return; } :