Cours 5

I. Types primitifs I.1 Déjà vus : boolean, int, long, double
I.2 "Nouveaux" : I.2.A float (réel/32 bits) : 6 chiffres significatifs, constantes littérales = 3.14F
I.2.B short (entier/16 bits, signé)
I.2.C byte (entier/8 bits, signé)
I.2.D char : - chaque caractère est codé par un entier sur 16 bits (et non plus 7 ou 8)
- C/C++: même nom, mais 8 bits, signé, ASCII
- JAVA: 16 bits, non signé, Unicode => 0..65535
- mais Unicode ⊃ ASCII (128 premiers caractères)
0 < contrôles < * < espace < * < chiffres < * < majuscules < * < minuscules < * ≤ 127
< ascii_étendu ≤ 255 < suite_unicode ≤ 65535
- constantes littérales '0'..'9', 'A'..'Z', 'a'..'z', '+' ou '\t'
- 3 affichages identiques, mais bien distinguer : 1 ≠ '1' ≠ "1" :
00000000000000000000000000000001
0000000000110001
10010011010111000011000111011100
- opérateurs de comparaison : les 6 habituels
- opérateur de conversion ←→ int
- opérateurs arithmétiques + et - : exemple: maj+'a'-'A' → min
- String s = "Bonjour"; char c = s.charAt(0); => c vaut 'B'
I.3 Résumé :
types primitifs = boolean + types "numériques"
types "numériques" = char + types entiers + types réels
types entiers = byte, short, int, long
types réels = float, double
I.4 Conversions (entre types primitifs)
I.4.A) Syntaxe : (type_primitif_souhaité)expression_d'un_autre_type_primitif
I.4.B) impossible : boolean ←→ autre_type
I.4.C) sans perte :
I.4.D) avec perte : les autres (y compris si même nombre d'octets ; pourquoi ?)
II. Tableaux II.1 Utilité - regroupement de données homogènes (et pour données hétérogènes ?)
- manipulation en une seule entité (notamment passage de paramètre)
- possibilité de faire des boucles (comment afficher tous les attributs d'un objet ?)
- Exemples sans tableau et avec tableau
II.2 Définition - tableau de taille fixe : à la compilation (C/C++) ou à l'exécution (Java)
- regroupement de données de même type, accessibles par leur rang, dont la taille est fixée à l'exécution, mais une fois pour toutes
II.3 Nouveau type - éléments de type T => tableau de type T[]
- considéré comme une classe => hérite d'Object => un tableau est un objet => référence
- attribut public length = taille du tableau = nombre de cases ≠ nombre d'éléments utiles
(et ne pas confondre avec la méthode length() de la classe String)
II.4 Déclaration - type var; => T[] aTab;
- T est n'importe quel type, primitif ou objet, y compris tableau
- déclaré mais pas créé => 0 cases mémoire
II.5 Création (=>allocation mémoire) - aTab = new T[taille];
- taille est une expression entière positive (pas long), sinon NegativeArraySizeException
- pour les variables locales, souvent en une seule fois : T[] vTab = new T[taille];
II.6 Accès à une valeur (lecture/écriture) - par le rang, appelé indice
- expression entière (pas long) entre 0 et aTab.length-1, sinon ArrayIndexOutOfBoundsException ! (gros avantage sur C/C++)
- 1ère valeur = aTab[0], ou aTab[2*i-1] = -x/2;
II.7 Initialisation - type primitif : typePrimitif var = expression;, exemple: double r = 3.14;
- type objet : Classe var = new Classe( valeurs );, exemples: Point p = new Point(2,4);
- classe particulière : String s = new String( "Bonjour" ); peut être abrégée en String s = "Bonjour";
- Tableau (syntaxe particulière) : int[] t; t = new int[] {10,20,30};
peut être abrégée en int[] t = {10,20,30}; uniquement dans une initialisation
- Exemple : int[] nbJours = {31, 28, 31, ..., 30, 31}; remplace les 13 lignes
int[] nbJours = new int[12];
nbJours[0] = 31; nbJours[1] = 28; ... nbJours[11] = 31;
II.8 Saisie/affichage : rien de prévu => à redéfinir soi-même ! (nbJours.toString() retourne "[I@abcdef")
II.9 fonctionnements non souhaités : = ne recopie pas les valeurs
== ne compare pas les valeurs
final ne protège pas les valeurs
II.10 java.util.Arrays (equals, toString, fill, sort, binarySearch) - méthodes statiques => un paramètre de plus !
- void fill(tab,val) remplit toutes les valeurs de tab avec val
- String toString(tab) retourne "[10, 20, 30]"
- boolean equals(tab1,tab2) compare les tailles et les valeurs des 2 tableaux
- void sort(tab) trie les valeurs de tab
- int binarySearch(tab,val) retourne l'indice de val trouvée dans tab
II.11 Cas particulier : caractères - Stringchar[] tc;
- mais String s = new String(tc); et tc = s.toCharArray();
- car String ne peut être modifiée alors que char[] si !
II.12 Multi-dimensionnels
II.12.a Un élément de tableau peut être de n'importe quel type, donc aussi un tableau ! Un tableau de tableau donne un tableau bi-dimensionnel.
II.12.b int[][] bidim = new int[3][2]; ==> nouveau type ( int[][] ) et 2 indices.
bidim[ligne][colonne] pour accéder à une case.
int[][] peut être vu comme un tableau de int[] (puisque X[] est un tableau de X)
Attention ! new int[3][2] ne signifie pas un tableau de 2 int[3] mais un tableau de 3 int[2] !
II.12.c initialisation possible : int[][] bidim = { {11, 12}, {21, 22}, {31, 32} };
II.12.d Un tableau peut avoir plus de 2 dimensions, et même plus de 5 ! Exemple :
    Pixel[][][][][][][] journee = new Pixel[20][10][30][25][3][1920][1080];
                                             ^   ^   ^   ^  ^     ^     ^
                            plages par journée   ^   ^   ^  ^     ^     ^
                                   spots par plage   ^   ^  ^     ^     ^
                                     secondes par spot   ^  ^     ^     ^
                                        images par seconde  ^     ^     ^
                                     plans couleurs par image     ^     ^
                                                    lignes par plan     ^
                                                       colonnes par ligne
et pourquoi pas par an, par chaîne, etc ...
II.12.e Arrays.deepToString( tab ) et Arrays.deepEquals( tab1, tab2 )
III. Boucles
III.1 Déjà vue : la boucle TANT QUE
while ( expression booléenne ) { instructions à répéter}
III.2 Nouvelle : la boucle POUR
III.2.A) Équivalente à la boucle while (intérêt syntaxique) :
initialisation; while ( condition de continuation ) { instructions à répéter; progression; }
initialisation: type_entier variable = expression_entière par exemple: int i=0
condition de continuation: comparaison sur la variable par exemple: i <= 15
progression: modification de la variable par exemple: i = i + 1
III.2.B) Syntaxe :
for ( initialisation; condition de continuation; progression ) { instructions }
par exemple: for ( int i=0; i<=15; i=i+1 ) { instructions }
Attention ! Seul cas en Java où le caractère ; ne termine pas une instruction.
III.2.C) Opérateurs souvent utilisés
i++ est équivalent à i=i+1 et non à i+1
i-- est équivalent à i=i-1 et non à i-1
i+=4 est équivalent à i=i+4 et non à i+4
i-=3 est équivalent à i=i-3 et non à i-3
i*=2 est équivalent à i=i*2 et non à i*2
III.2.D) Imbrication : 2 for, 2 compteurs (1 lent, 1 rapide), notamment pour les tableaux bi-dimensionnels
III.3 Nouvelle : la boucle FAIRE TANT QUE
III.3.A)
- "contraire" de la boucle Répéter jusqu'à que l'on trouve dans d'autres langages
- intérêt : instructions toujours exécutées au moins 1 fois avant le test de continuation
III.4.B) do while :
do { instructions à répéter } while ( expression booléenne );
- nombre de tours inconnu a priori
- test à la fin, tourne au moins une fois
- équivalente à :
instructions à répéter while ( expression booléenne ) { instructions à répéter }
III.4 Critères de choix : 2 questions successives
- première question à se poser :
le nb de tours peut-il être connu à l'avance ?
- si OUI, c'est une boucle for
- si NON, seconde question à se poser :
l'instruction dans la boucle doit-elle être exécutée au moins une fois ?
- si OUI, c'est une boucle do while
- si NON, c'est une boucle while

IV. Développer sans BlueJ (et sans IDE)
IV.1 Édition de texte (nedit, emacs, nano, vi, vim, notepad, kwrite, kate, ultraedit, ...)
nedit UneClasse.java & IV.2 Compilation
javac UneClasse.java   ou   javac *.java
IV.3 Exécution
java UneClasse   ou   java UneClasse mot1 mot2
mais quelle méthode est lancée ? (signature recherchée, sinon NoSuchMethodError)
IV.4 Signature obligatoire pour cette méthode :
    public static void main( String[] pArgs ) { instructions }
    ^^3^^^ ^^4^^^ ^2^^ ^1^^  ^^^5^^^^ ^^6^^     ^^^^^7^^^^^^
- 1: le nom est imposé (veut dire "principal")
- 2: car c'est une procédure (qui ne retourne rien)
- 3: car elle est appelée en dehors de la classe (par le système d'exploitation)
- 4: car il serait ennuyeux que le système d'exploitation doive d'abord créer un objet avant de pouvoir appeler cette procédure
- 5: un et un seul paramètre obligatoire (aucun=interdit, 2 ou plus=interdit) et forcément du type tableau de String
la taille est facilement disponible et pArgs[0] contient le premier argument après java NomClasse
(alors que c'est argv[1] en C ou C++)
par exemple, si la commande est celle en orange ci-dessus, pArgs sera composé des 2 String "mot1" et "mot2"
- 6: seule liberté : le choix du nom du paramètre (mais presque tout le monde utilise args !)
- 7: Si le corps est vide, le programme ne fera rien. S'il se termine par System.exit( valeur ); ,
la valeur sera retournée au système d'exploitation comme code d'erreur (0 s'il n'y a pas d'erreur).
IV.5 Documentation
publique (pour les utilisateurs de la classe) : javadoc *.java -author -version -drépertoire privée (pour les programmeurs, maintenance de la classe) : javadoc *.java -author -version -drépertoire -private -linksource
V. Style d'écriture des programmes en Java : recommandations à respecter (rappels)

Lire le poly :
tout jusqu'à la section 2.4.1, sections 2.5, 3.1, 3.2.2, 3.6, 4, 5.1, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, 8.2.2, 9.1 à 9.5, 13.3, et annexes 6 & 7


--> Dernière mise à jour :