LECTURE ET ECRITURE DEPUIS LA CONSOLE : LES VARIABLES
Nous allons commencer ici par installer les logiciels et mise à jour nécessaire à la programmation en JAVA.
1-Les logiciels de base
Il nous faut d'abord télécharger le JDK, Java Development Kit.
01° Faire une recherche en utilisant les mots-clé "Java JDK" et vous devriez arriver sur le site de Orale, sociète développant actuellement JAVA. : ICI
02° Il ne vous reste qu'à chercher le Java SE Development Kit dans la section des téléchargements, version 8 au moment où j'écrit ces lignes. Prenez la version x64 pour un ordianteur 64 bits ou la version x86 pour un ordinateur 32bits. Vous pourrez trouver les informations sur votre ordinateur dans le panneau de configuration, dans la section Système.
03° Aller sur le site d'Eclipse et installer Eclipse IDE : ce logiciel est un environnement de développement Java.
Encore une fois, vous aurez la version 32 bits ou 64 bits.
04° Lancer Eclipse.
05° Sélectionner un espace de travail (workspace)
06° Lancer un nouveau projet JAVA nommé monpremierprojet. Pour cela, vous avez deux possibilités : la première est de fermer la fenêtre d'accueil (la croix en haut) et la seconde d'utiliser Create a new Java Project.
Dans tous les cas, vous allez ensuite devoir utiliser le menu File - New - Class.
07° Sélectionner bien votre projet et lui rajouter une « class » (considérez cela comme un programme pour l'instant) qu’on nomme mapremiereclass. Pensez également à rajouter le dossier qui contiendra la class et à cocher la case public static void main.
08° On obtient un premier fichier qui est nommé main et qui est exécuté lorsqu’on appelle la class.
Le programme ne comporte que des commentaires pour l'instant : la ligne commençant par //. Cette ligne s'affiche en vert pour bien indiquer que celle-ci ne sera pas interpréter en code : on peut donc y insérer toutes les indications et précisions destinées à un lecteur humain qui lira votre code. Peut-être vous même dans plusieurs mois.
Quelques explications sur le nom de votre première classe : .
Le mot-clé public veut dire qu'on pourra accéder à votre classe sans aucune contrainte. C'est mieux car si on ne pouvait pas y accéder directement, je ne vois pas comment on pourrait faire pour l'instant...
Le mot-clé static veut dire que votre méthode n'est pas appliquée à un objet en particulier : on va pouvoir lancer votre méthode même si aucun autre objet n'a été créé.
Le mot-clé void veut dire que votre méthode ne revoit rien : elle s'execute et ne communique aucun résultat à qui que ce soit une fois finie.
Son nom main n'est pas directement un mot-clé : c'est cette méthode qui sera appellé la première lors du lancement de cette classe.
String[] args est obligatoire : cela permet de lancer votre méthode en utilisant certains cas particuliers. On crée alors une "variable" vars de type String qui va contenir une chaîne de caractères. Par l'instant, on peut mettre de côté l'intéret de cette notation, il suffit de lui laisser noter tout cela sans l'effacer.
2 - Afficher sur la console
Voilà un bout de code qui va vous permettre d'afficher un message sur la console.
public static void main(String[] args){
System.out.print("Salut à tous !");
}
On notera que les deux accolades { ... } indiquent où commence la suite d'instructions et où elle finit. Elles sont surlignées sur le code précédent pour que vous vous rendiez bien compte de leurs existences. En cas d'absence, votre programme ne pourra pas tourner.
On remarquera également les instructions sont finalisées par un point-virgule(;). C'est ainsi qu'on signale en Java que l'ordinateur peut passe à l'instruction suivante. Le passage à la ligne dans le code n'est pas suffisant : c'est bien le symbole point-virgule qui lui donne cette information.
09° Recopier le code dans votre méthode main et lancer le code en appuyant sur la petite flèche verte
On y appelle la méthode print appartenant à un ensemble System.out (ensemble qui gère les sorties vers l’écran notamment).
On remarquera toute de suite qu'on a un point entre print et System.out : System.out.print.
On peut rajouter des commentaires qui ne seront pas lus par le programme à l’aide « // » en début de ligne. Cela vous permet de noter des indications permettant de comprendre le code plusieurs mois après l’avoir conçu. Ou encore mieux, cela permet à quelqu’un qui n’a pas conçu le code de le comprendre et de le modifier à sa guise.
10° Rajouter un commentaire au programme précédent : cela devrait vous montrer que le logiciel ne traite vraiment pas votre texte comme une instruction à respecter. En relançant le programme, cela ne devrait rien changer.
11° Et si on veut afficher un truc sur plusieurs lignes ?
public static void main(String[] args){
System.out.print("Salut à tous !");
System.out.print("Mon nom est ");
}
Lancez. Et bien non, ça ne marche pas.
On remarque néanmoins que chaque instruction finit par un point-virgule.
La fonction println (l comme ligne et n comme nom : ln) permet d’afficher le message puis de passer à la ligne. Rajouter \n dans le texte à afficher permet également de passer à la ligne. System.out.print("Salut à\ntous !") va afficher "Salut à" sur une premièr ligne et "tous !" sur la deuxième ligne.
Pour passer à la ligne, on peut donc utiliser soit println("Bonjour à tous !"); soit print("Bonjour à tous !\n");.
12° Afficher correctement à l’écran le message suivant :
Salut à tous !
Mon nom est VOTREPRENOMICI
Et c’est mon premier vrai programme.
Autres petites astuces
Certains caractères sont impossibles à afficher directement. Le caractère le plus évident est la double guillemet puisqu'elle sert normalement à indiquer le début et la fin de la chaîne de caractère.
- \" permet d’afficher un " à l’écran.
- \r permet de faire un retour chariot.
- \t permet de faire une tabulation.
13° Devinez ce qu’affiche le programme suivant. Notez votre réponse puis lancez :
public static void main(String[] args){
System.out.println("Salut \rà tous !");
System.out.print("Mon nom est ");
System.out.print("\tArthur\tBertrand\tou\tCharlie");
}
3 - Lire l'entrée clavier
Nous savons maintenant écrire sur la console. Il nous reste à voir comment lire une entrée clavier.
14° Créer une nouvelle classe nommée par exemple lectureclavier (n'oubliez pas de cocher public) et rajouter le code suivant :
Scanner sc = new Scanner(System.in);
Vous devriez avoir une jolie vague rouge sous le mot Scanner. Cliquez sur la croix rouge sur la gauche et faites un double-clic sur Import 'Scanner' java.util (figure suivante).
Et là, l'erreur disparaît !
Le code import java.util.Scanner; est apparu au début de la déclaration de la class : elle va désormais aller chercher dans la bibliothèque de fonction java.util (ou package) la classe nommée Scanner.
Et là, l'erreur disparaît !
Les classes et leurs importations
Voyez pour l'instant une classe comme un ensemble de code qui permet de gérer des objets sans se soucier de la façon dont la personne à coder la classe. Il faut voir cela comme une interface : on ne peut lui donner que des ordres prédéfinis par le créateur de la boite (on appelle ces ordres des méthodes). Cela évite qu'on ne détruise par inadvertance le code de la classe en modifiant de façon incorrecte une partie du code. C'est le principe de la voiture qu'on conduit : vous avez le volant, les pédales ect ... Vous ne pouvez pas modifier le moteur ou les programmes de gestion de la voiture pendant que vous roulez. Vous lui donner l'ordre d'accélérer, elle accélère et c'est tout. Tout le fonctionnement interne est totalement caché et inaccessible.
Ainsi, quelqu'un peut créer une classe image et ainsi, on pourrait gérer les images à l'aide des méthodes que la personne a créé. C'est ce que vous avez fait avec le print et le println : vous avez utilisé la méthode qui s'applique à la classe System sans avoir à connaitre comment la personne qui a codé la méthode print a fait cela. On l'utilise, on ne peut pas la faire bugger et ça marche. C'est le principe de la programmation orienté objet : on crée des codes qui permettent de gérer des objets et ensuite on utilise ces codes sans pouvoir les modifier. Cela garantit ainsi une très bonne stabilité à l'ensemble du programme et une meilleur visibilité et compréhension de l'ensemble.
Gardez donc l'image de la voiture pour l'instant : la classe est la Voiture, les objets sont des voitures spécifiques (chacune ayant une plaque d'immatriculation) et les méthodes publiques sont les fonctions auquelles le créateur de la classe vous a donné accès car il a estimé que vous ne pouviez pas casser son code en l'utilisant. Sur votre voiture, les méthodes sont
- tourner le volant,
- accélérer,
- freiner,
- activer les essuis-glaces ...
Les classes qui se trouvent dans les packages autres que java.lang (package automatiquement importé par Java, on y trouve entre autres la classe System) sont à importer à la main pour pouvoir vous en servir. La façon dont nous avons importé la classe java.util.Scanner dans Eclipse est très commode. Vous pouvez aussi le faire manuellement à l’aide du code suivant par exemple :
//Ceci importe la classe Scanner du package java.util
import java.util.Scanner;
//Ceci importe toutes les classes du package java.util
import java.util.*;
public class lectureclavier {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);;
}
}
Que veut dire le code Scanner sc = .. : nous gardons une place mémoire qu'on nomme sc qui peut contenir un objet basé sur la classe Scanner (on dit également que sc est une instance de la classe Scanner). sc pourra donc contenir un objet de classe Scanner.
Mais que contient notre objet ? Il faut regarder de l'autre côté du signe égal : = new Scanner(System.in);: cela veut dire qu'on affecte à sc une instance de Scanner qui observe ce qui rentre dans System (c'est noté avec System.in).
Scanner sc = new Scanner(System.in);
Passons à la pratique : :
15° Remplir la méthode main à l'aide du code suivant : nous allons faire notre premier programme interactif : nous allons lire un nom rentré au clavier et le réafficher à l'écran. Groovy. Lancer le code, tapé un nom et observer.
public static void main(String[] args){
// Déclare et crée une instance de la classe Scanner nommée sc qui contiendra l’entrée clavier.
Scanner sc= new Scanner(System.in);
// Ecrit la demande à l’écran
System.out.println("Veuillez saisir votre prénom :");
// Déclare et crée une instance de la classe String (chaine de caractères)nommée str qui va contenir ce qu'on écoute sur sc (l’entrée clavier) jusqu’au passage à la ligne(d'où le nexLine().
String str = sc.nextLine();
// Ecrit sur la console le contenu de la variable str
System.out.println("Vous avez saisi : " + str);
}
16° Relancer le code mais taper un nombre cette fois.
Bien, cela semble fonctionner avec les entrées alphabétiques et numériques.
17° Créer votre premier programme : demander à l'utilisateur de rentrer deux nombres et afficher ensuite la somme des deux nombres rentrés.
Vous pourrez trouver une version possible du programme voulu dans le fichier texte que je vous ai fourni. N'allez pas voir trop tôt : c'est toujours facile avec la correction.
Pas facile n’est pas ? Vous devriez réussir à afficher 73 en rentrer 7 et 3. Pas terrible comme calcul…
4 - Les types de variables contenant des nombres
Ou : Le bon type de variable pour le bon type d’action.
Puisqu’on veut faire du calcul, il ne faut pas chercher à stocker la réponse dans une variable "chaîne de caractère" (String) mais bien dans une variable "nombre".
On peut stocker un nombre entier dans les variables de type Integer qu'on déclare à l'aide de int.
Le type int code le nombre entier sur 4 octets. Il peut stocker des nombres positifs ou négatifs allant de - 2 147 483 648 à + 2 147 488 647. Cela devrait suffire pour notre exemple.
18° Utiliser le code suivant pour parvenir enfin à additionner des nombres plutôt que des caractères.
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("Veuillez saisir un nombre :\n");
int str1 = sc.nextInt();
System.out.println("Veuillez saisir un second nombre :\n");
int str2 = sc.nextInt();
int somme = str1 + str2;
System.out.println("La somme donne : " + somme);
}
Remarque : Il existe des « règles » liées à la nomination des variables que la plupart des programmateurs respectes car elle permet de faire facilement la différence entre variable et fonction :
- Le nom d’une variable doit être explicite dans le cadre du programme.
- Le nom d’une variable doit être composé de minuscule : exemple avec argent ou age ou nom.
- Si elle se compose de plusieurs mots, on sépare les différents mots par un underscore ( _ ) : argent_poche_droite.
- Si elle se compose de plusieurs mots et que le langage différencie majuscule et minuscule, on place la première lettre de chaque mot en majuscule (sauf le premier qui reste intégralement en minuscule) : argentPocheDroite.
Donc, cela fonctionne : 7 + 3 donne bien 10. Quelle est la différence avec le cas précédent ? Nous avons premièrement déclaré des integers plutôt que des Strings et ensuite, nous avons changé la méthode utilisée pour lire le résultat clavier : de nextLine() nous sommes passés à nextInt() : nous avons donc placé l'entier tapé au clavier et détécté par la méthode nextInt() dans une variable adaptée : un integer.
Au passage, regardez bien comment nous avons appliqué la méthode : on utilise un point entre l'objet étudié (sc ici) et la méthode utilisée (nexInt()).
int str2 = sc.nextInt();
Au passage, nous remarquerons que le nom des variables utilisées pour stocker les entrées clavier ne sont plus très adaptées : j'avais utilisé initialement str1 pour indiquer qu'il s'agissait de String. J'aurai pû le renommer en int1 et int2 par exemple. Il existe d'ailleurs des codeurs qui utilisent une règle qui consiste à noter le nom du type de variable devant la variable. C'est pratique car cela permet de savoir ce qu'une variable est censée contenir. C'est par contre un peu génant si on change d'avis ou que le type de contenu n'est pas fixe, comme avec notre entrée clavier. J'utiliserai les deux façons de faire au cas par cas par la suite.
19° Créer un programme qui demande le nom d'un élève, qui demande trois de ces notes (entières) et qui en fait la moyenne. Tester avec 10, 11 et 20. Nous devrions obtenir 13.7.
Normalement, si vous n'avez pas utilisé d'autres connaissances que celles abordées pour l'instant, vous devriez avoir trouvé 13 plutôt que 13.3. C'est embarrassant. En plus, il arrondit par le bas.
Voilà un exemple de code qui vous auriez pu créer :
import java.util.Scanner;
public class lectureclavier {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.print("Veuillez saisir le nom de l'élève :");
String sNom = sc.nextLine();
System.out.print("Veuillez donner les 3 notes en tapant entrée entre chaque note :\n");
int iNote1 = sc.nextInt();
int iNote2 = sc.nextInt();
int iNote3 = sc.nextInt();
int moyenne = (iNote1+iNote2+iNote3)/3;
System.out.print("La moyenne de " + sNom + " est de : " + moyenne);
}
}
On lit avec la méthode nextLine() le nom qu'on place dans un String nommé sNom.
On lit les trois notes avec la méthode nextInt() et on les place dans des int nommés iNote1 à iNote3.
Et c'est là qu'est le problème : on calcule la moyenne en plaçant le résultat dans un int, donc un entier. 13.7 est donc tronqué et on ne garde que 13.
Comment faire pour obtenir le bon résultat ? Choisir le bon type de variable ! Il faut signaler que moyenne doit contenir un nombre à virgule, typé par float plutôt que int.
20° Remplacer la déclaration de la variable contenant la moyenne par float moyenne = (iNote1+iNote2+iNote3)/3;. Observer le résultat.
Encore raté. On progresse notez bien. Il devrait noter 13.0, on a une virgule maintenant.
Au passage, vous pouvez voir que 13 virgule 0 est noté 13 point 0. Faites extrémement attention à ce point lorsque vous voudrez donner des nombres réels. L'ordinateur ne comprendra pas votre virgule, il a besoin d'un point. Surtout qu'il est plus que probable que votre console soit configuré en version française : il vous faudra taper 10,0 par exemple, mais cela serait affiché 10.0. Pour l'instant, nous ferons avec ce défaut.
21° Rajouter quelques lignes de code pour lire un float en utilisant la méthode nextFloat() et demander de l'afficher directement sur la console.
float fTest = sc.nextFloat();
System.out.println(fTest);
Et voilà : on tape 14,3 et il écrit sur la console 14.3. Encore une différence entre l'écriture latine et anglosaxone.
Bon, comment avancer sur le problème de la moyenne ? D'abord regardons d'où vient le problème : on additionne 3 integers et cela nous donne un integer. On divise ensuite cette integer par un 3. Or, ce 3 est stocké comme un integer par le logiciel. Il cherche ainsi à stocker le résultat dans un integer puisqu'il n'y a que ça partout. Il ne garde donc que le 13 de 13.7... Le fait que la variable moyenne soit déclarée en float ne change rien à l'affaire : on peut très bien stocker 13 dans un float.
La solution la plus facile consiste alors à diviser par 3 en le forçant à voir ce 3 comme un nombre réel de type float. On notera simplement 3f plutôt que 3.
22° Tester pour voir la différence.
Cela fonctionne mais ça ressemble un peu à du bricolage : il faudrait s'arranger pour trouver un nombre à convertir à chaque fois.
En fait, il existe un opérateur qui permet de forcer les conversions d'un type de variable vers un autre : l'opérateur de cast.
Il s'utilise de façon très simple : il suffit de placer le type de la variable voulue (entre parenthèses) juste avant l'expression qu'on veut convertir.
Exemple : float moyenne = (float)((iNote1+iNote2+iNote3)/3); fera la conversion sans avoir à déclarer 3 comme un float.
23° Créer maintenant un programme qui accepte des notes réelles (à virgules) et qui stocke la moyenne dans un float.
24° Rajouter une ligne pour arrondir à l'entier la moyenne. On pourra utiliser un opérateur de cas noté (int) pour obtenir ce résultat.
Les autres types d'entier
Il existe en réalité 4 types d'entier en Java. Chaque type peut coder un nombre plus ou moins grand.
| Type | Taille | Valeur min | Valeur max |
|---|---|---|---|
| byte | 1 octet | -128 | +127 |
| short | 2 octets | -32768 | +32767 |
| int | 4 octets | -2,1 milliards environ | +2,1 milliards environ |
| long | 8 octets | -9 milliards de milliards environ | +9 milliards de milliards environ |
Les constantes (comme 3) sont de type int ou long en fonction de la valeur à contenir. On peut forcer 3 à être long en tapant 3L.
Le type basique des entiers en l'integer int. Ainsi quand vous tapez 12, l'ordinateur le stocke de base dans un integer. S'il est trop grand pour être stocké dans un integer, il le stocke dans un long.
Pourquoi ne pas tout mettre en type long ? Pour une question de place mémoire : le type long prend 8 octets de mémoire, deux fois plus que l'int. Si vous devez stocker 10 variables, ce n'est pas grave. Avec 3 milliards, ça devient plus encombrant : vos données prendrait 24 Méga Octets (3*8) plutôt que 12 Mo si les nombres étaient stockés en int.
Les autres types de nombre réel
Il existe 2 types de réels en Java. Chaque type peut coder un nombre positif ou négatif plus ou moins grand. On donne ci-dessous les valeurs minimales et maximales de la valeur absolue.
Nous avons vu qu'on peut forcer 3 à être vu comme un réel en notant 3f.
| Type | Taille | Valeur min | Valeur max | Chiffres significatifs |
|---|---|---|---|---|
| float | 4 octets | Environ 1.40E-45 | Environ 3,4E38 | 7 |
| double | 8 octets | Environ 4.94E-324 | Environ 1.80E308 | 15 |
A titre d'exemple, la moyenne de 10, 11 et 20 donne 13.666666666666666 avec un calcul en type double.
double moyenne = (double)(iNote1+iNote2+iNote3)/3;
A titre d'exemple, la moyenne de 10, 11 et 20 donne 13.666667 avec un calcul en type float.
float moyenne = (float)(iNote1+iNote2+iNote3)/3;
On voit donc que le type double permet de stocker des nombres plus grand, plus petit et avec une meilleur précision.
Nous sommes bien loin d'avoir fait le tour de la question sur l'affectation des variables en entier ou réel mais vous avez les bases. Il faudra faire attention à vos types en attendant de mieux comprendre le fonctionnement interne
D'ailleurs comment trouver les valeurs exactes des valeurs minimales et maximales ? Et bien, il suffit de lui demander de les afficher : elles sont stockées en tant que constantes dans le code.
Attention, il faudra utiliser le type de la variable mais avec une majuscule sur sa première lettre contrairement à la déclaration d'une variable.
Deuxièmement, les constantes sont toujours notées intégralement en majuscules.
Exemple 1 : Int.MIN_VALUE contient la valeur minimale que peut prendre une variable int.
Exemple 2 : Float.MAX_VALUE contient la valeur maximale que peut prendre une variable float.
25° Créer un programme qui permet d'afficher les valeurs min et max des différents types de variables.
5 - Les types de variables contenant des caractères
Là, ca va aller plus vite car nous avons déjà vu celui qui permet de stocker des chaines de caractères : String. Pourquoi avec un S majuscule alors que les autres s'écrivent avec une minuscule ? C'est simple : en réalité, String est une classe d'objets. On l'écrit donc avec une majuscule. Comme Scanner ou System. Pour faire simple, String est une classe qui place des caractères les uns derrière les autres. Il existe donc un type particulier de variable qu'on nomme le caractère : char.
Pour cette première approche, vous n'aurez donc qu'à vous demander si vous voulez stocker un seul caractère (et donc on prendra un type char) ou si vous voulez stocker une chaîne de caractères (et on prendra un String)/
Au niveau de l'affectation, on notera une différence importante entre les guillements doubles pour les strings et l'apostrophe pour les caractères :
String ma_chaine = "Bonjour";
char mon_caractere = 'a';
Néanmoins, Scanner ne gère pas directement les caractères seuls, nous allons donc utiliser un autre type de connaissance pour faire l'exercice pratique.
UNICODE
L'ordinateur ne sait pas stocker de caractères en mémoire : il ne stocke que des nombres.
Lorsqu'on lui demande de stocker un caractère, il stocke donc un nombre entier codant ce caractère.
Le premier code de ce type fut le code ASCII qui code les caractères visibles et invisibles de 0 à 127, sur 7 bits.
Voilà la fameuse table de correspondance ASCII :
Les premiers de la liste sont des caractères de contrôle et de gestion, non affichés à l'écran :
| Type | Décimal | Symbole | Signification | Binaire |
|---|---|---|---|---|
| Contrôle | 0 | NULL or NUL | Null | 000 0000 |
| Contrôle | 1 | SOM or SOH | Start of Heading | 000 0001 |
| Contrôle | 2 | EOA or STX | Start of Text | 000 0010 |
| Contrôle | 3 | EOM or ETX | End of Text | 000 0011 |
| Contrôle | 4 | EOT | End of Transmission | 000 0100 |
| Contrôle | 5 | WRU or ENQ | Enquiry | 000 0101 |
| Contrôle | 6 | RU or ACK | Acknowledgement | 000 0110 |
| Contrôle | 7 | BELL or BEL | Bell | 000 0111 |
| Contrôle | 8 | FE0 or BS | Backspace | 000 1000 |
| Contrôle | 9 | HT/SK or HT | Horizontal Tab | 000 1001 |
| Contrôle | 10 | LF | Line Feed | 000 1010 |
| Contrôle | 11 | VTAB or VT | Vertical Tab | 000 1011 |
| Contrôle | 12 | FF | Form Feed | 000 1100 |
| Contrôle | 13 | CR | Carriage Return | 000 1101 |
| Contrôle | 14 | SO | Shift Out | 000 1110 |
| Contrôle | 15 | SI | Shift In | 000 1111 |
| Contrôle | 16 | DC0 or DLE | Data Link Escape | 001 0000 |
| Contrôle | 17 | DC1 | Device Control 1 | 001 0001 |
| Contrôle | 18 | DC2 | Device Control 2 | 001 0010 |
| Contrôle | 19 | DC3 | Device Control 3 | 001 0011 |
| Contrôle | 20 | DC4 | Device Control 4 | 001 0100 |
| Contrôle | 21 | ERR or NAK | Negative Acknowledgement | 001 0101 |
| Contrôle | 22 | SYNC or SYN | Synchronous Idle | 001 0110 |
| Contrôle | 23 | LEM or ETB | End of Transmission Block | 001 0111 |
| Contrôle | 24 | S0 or CAN | Cancel | 001 1000 |
| Contrôle | 25 | S1 or EM | End of Medium | 001 1001 |
| Contrôle | 26 | S2 or SS | Substitute | 001 1010 |
| Contrôle | 27 | S3 or ESC | Escape | 001 1011 |
| Contrôle | 28 | S4 or FS | File Separator | 001 1100 |
| Contrôle | 29 | S5 or GS | Group Separator | 001 1101 |
| Contrôle | 30 | S6 or RS | Record Separator | 001 1110 |
| Contrôle | 31 | S7 or US | Unit Separator | 001 1111 |
Et à partir de 32, on trouve les caractères dits imprimables car visibles à l'écran :
| Type | Décimal | Symbole | Signification | Binaire |
|---|---|---|---|---|
| Printable | 32 | (space) | (space) | 010 0000 |
L'espace est un caractère un peu spécial mais les autres sont visibles :
| Type | Décimal | Symbole | Binaire |
|---|---|---|---|
| Printable | 33 | ! | 010 0001 |
| Printable | 34 | " | 010 0010 |
| Printable | 35 | # | 010 0011 |
| Printable | 36 | $ | 010 0100 |
| Printable | 37 | % | 010 0101 |
| Printable | 38 | & | 010 0110 |
| Printable | 39 | ' | 010 0111 |
| Printable | 40 | ( | 010 1000 |
| Printable | 41 | ) | 010 1001 |
| Printable | 42 | * | 010 1010 |
| Printable | 43 | + | 010 1011 |
| Printable | 44 | , | 010 1100 |
| Printable | 45 | - | 010 1101 |
| Printable | 46 | . | 010 1110 |
| Printable | 47 | / | 010 1111 |
| Printable | 48 | 0 | 011 0000 |
| Printable | 49 | 1 | 011 0001 |
| Printable | 50 | 2 | 011 0010 |
| Printable | 51 | 3 | 011 0011 |
| Printable | 52 | 4 | 011 0100 |
| Printable | 53 | 5 | 011 0101 |
| Printable | 54 | 6 | 011 0110 |
| Printable | 55 | 7 | 011 0111 |
| Printable | 56 | 8 | 011 1000 |
| Printable | 57 | 9 | 011 1001 |
| Printable | 58 | : | 011 1010 |
| Printable | 59 | ; | 011 1011 |
| Printable | 60 | < | 011 1100 |
| Printable | 61 | = | 011 1101 |
| Printable | 62 | > | 011 1110 |
| Printable | 63 | ? | 011 1111 |
| Printable | 64 | @ | 100 0000 |
| Printable | 65 | A | 100 0001 |
| Printable | 66 | B | 100 0010 |
| Printable | 67 | C | 100 0011 |
| Printable | 68 | D | 100 0100 |
| Printable | 69 | E | 100 0101 |
| Printable | 70 | F | 100 0110 |
| Printable | 71 | G | 100 0111 |
| Printable | 72 | H | 100 1000 |
| Printable | 73 | I | 100 1001 |
| Printable | 74 | J | 100 1010 |
| Printable | 75 | K | 100 1011 |
| Printable | 76 | L | 100 1100 |
| Printable | 77 | M | 100 1101 |
| Printable | 78 | N | 100 1110 |
| Printable | 79 | O | 100 1111 |
| Printable | 80 | P | 101 0000 |
| Printable | 81 | Q | 101 0001 |
| Printable | 82 | R | 101 0010 |
| Printable | 83 | S | 101 0011 |
| Printable | 84 | T | 101 0100 |
| Printable | 85 | U | 101 0101 |
| Printable | 86 | V | 101 0110 |
| Printable | 87 | W | 101 0111 |
| Printable | 88 | X | 101 1000 |
| Printable | 89 | Y | 101 1001 |
| Printable | 90 | Z | 101 1010 |
| Printable | 91 | [ | 101 1011 |
| Printable | 92 | \ | 101 1100 |
| Printable | 93 | ] | 101 1101 |
| Printable | 94 | ^ | 101 1110 |
| Printable | 95 | _ | 101 1111 |
| Printable | 96 | ` | 110 0000 |
| Printable | 97 | a | 110 0001 |
| Printable | 98 | b | 110 0010 |
| Printable | 99 | c | 110 0011 |
| Printable | 100 | d | 110 0100 |
| Printable | 101 | e | 110 0101 |
| Printable | 102 | f | 110 0110 |
| Printable | 103 | g | 110 0111 |
| Printable | 104 | h | 110 1000 |
| Printable | 105 | i | 110 1001 |
| Printable | 106 | j | 110 1010 |
| Printable | 107 | k | 110 1011 |
| Printable | 108 | l | 110 1100 |
| Printable | 109 | m | 110 1101 |
| Printable | 110 | n | 110 1110 |
| Printable | 111 | o | 110 1111 |
| Printable | 112 | p | 111 0000 |
| Printable | 113 | q | 111 0001 |
| Printable | 114 | r | 111 0010 |
| Printable | 115 | s | 111 0011 |
| Printable | 116 | t | 111 0100 |
| Printable | 117 | u | 111 0101 |
| Printable | 118 | v | 111 0110 |
| Printable | 119 | w | 111 0111 |
| Printable | 120 | x | 111 1000 |
| Printable | 121 | y | 111 1001 |
| Printable | 122 | z | 111 1010 |
| Printable | 123 | { | 111 1011 |
| Printable | 124 | | | 111 1100 |
| Printable | 125 | } | 111 1101 |
| Printable | 126 | ~ | 111 1110 |
Le numéro 127 correspond à la touche DEL d'effacement :
| Type | Décimal | Symbole | Signification | Binaire |
|---|---|---|---|---|
| Contrôle | 127 | DEL | 111 1111 |
Ensuite, la taille des mémoires augmentant, on a pu utiliser 8 bits (1 octet) pour représenter les caractères.
En rajoutant un bit, on avait accès à de nouvelles valeurs allant de 128 à 255.
On a pu rajouter les accents et autres caractères étranges. Mais impossible de créer un code unique : il n'y avait pas assez de nombres pour tous les caractères exotiques pour les anglosaxons.
On parle alors de code ASCII étendu, le plus commun en Europe étant le Latin-1 ou ANSI qui correspond aux lettres spéciales de l'Europe de l'Ouest.
Avec la mondialisation, un nouvel encodage est apparu : l'UNICODE qui code les caractères sur plusieurs octets, offrant ainsi toutes les possibilités mais prenant plus de place en mémoire : chaque caractère prend plus de place mémoire.
JAVA utilise l'Unicode pour stocker ses caractères.
Comment connaitre l'encodage unicode d'un caractère ? Les premiers sont similaires à l'ASCII. Mais les autres ?
Pour vous amuser, voilà un programme qui vous montre qu'on peut déclarer un caractère soit
- avec les apostrophes et en tapant le caractère :
char monCar = 'a'; - avec son numéro de code :
char monCar = 97;
Dans les deux cas, si on affiche le caractère monCar, on aura le caractère a à l'écran !
Et si on veut récupérer le code chiffré d'un caractère, il suffit d'utiliser un opérateur de cast pour transformer le caractère en nombre entier : taper (int)monCar et cela renvoie la valeur du code correspondant.
public class lectureclavier {
public static void main(String[] args){
/* *****************************************************
1 - Pour déclarer et afficher un caractère "normalement"
****************************************************** */
System.out.println("TEST SUR cmonCarac1 déclaré comme char et initialisé avec les apostrophes");
char cmonCarac1 = 'a';
System.out.println("Le caractère stocké dans cmonCarac1 est " + cmonCarac1);
// Si on veut afficher le code qu'à ce caractère
System.out.println("Et son code vaut " + (int)cmonCarac1);
/* **************************************************************
2 - Pour déclarer et afficher un caractère à partir de son code
*************************************************************** */
System.out.println("TEST SUR cmonCarac2 déclaré comme char et initialisé avec son code");
char cmonCarac2 = 97; // On donne juste le numéro mais on déclare un char
System.out.println("Le caractère stocké dans cmonCarac2 est " + cmonCarac2 ); //Il affiche bien le a pas 97
// Si on veut retrouver le code
System.out.println("Le code de cmonCarac2 est " + (int)cmonCarac2);
}
}
26° Utilisez le code, tentez de bien le comprendre et constatez qu'on peut initialiser un char avec sa version caractère ou sa version codée.
27° Modifiez légérement le code pour répondre à cette question : à quel caractère correspond le code 8364 ?
Il nous reste à voir comment faire une autre conversion : comment convertir un integer rentré au clavier en son caractère correspondant ?
Un indice : opérateur de cast.
Et comme nous voulons convertir le tout en caractère, peut-être pourrions-nous essayer un (char) ?
28° Créer un code qui demande un integer à l'utilisateur et qui affiche ensuite le caractère correspondant.
Et voilà une correction possible :
import java.util.Scanner;
public class lectureclavier {
public static void main(String[] args){
/* *****************************************************
3 - Pour convertir un integer en char *"
****************************************************** */
System.out.println("TEST SUR un int qu'on tente d'attribuer à un caractère");
Scanner sc = new Scanner(System.in);
System.out.println("Veuillez taper le code recherché\n");
int iCode = sc.nextInt();
System.out.println("Vous avez tapé le nombre " + iCode + " et cela correspond au caractère "+ (char)iCode);
}
}
29° Et si vous tentiez de retrouver le caractère correspondant à 8364 ?
30° Et voilà, c'est fini pour aujourd'hui. Il reste à voir le type boolean qui correspond à des variables ne pouvant être que true ou false. Nous les verrons dans le prochain épisode. Mais il reste encore beaucoup de choses sympathiques à faire avec Scanner. Pourquoi ne pas faire une recherche Internet "Java+Scanner". Il est temps de tenter de trouver de la documentation par vous-même.
Les commentaires : Il existe d'autres façons d'insérer des commentaires dans le code. L'utilisation de // est commune avec le C++ mais on peut également insérer des commentaires en utilisant /* en ouverture et */ en fermeture comme en C ou en CSS. L'avantage de cette méthode est que le commentaire pourra se faire sur plusieurs lignes puisqu'il y a un commencement (/*) et une fin (*/) alors qu'avec // le commentaire ne possède qu'un début et s'arrête automatiquement lors du saut de ligne.
On trouve également la possibilité de créer des commentaires de documentation automatique. Faites une recherche Internet si vous désirez plus d'informations à ce sujet.