1.

Architecture minimale d'un programme Java

Exemple Zero : Architecture minimale

1. public class QuiNeFaitRien

2. {
3.
4. public static void main (String [] args)
5. {
6.
7. }
8.
9. }

Lorsque vous écrivez un programme java, vous aurez à écrire au minimum ce qui se trouve dans l'exemple
zéro.
Le nom de ce programme est QuiNeFaitRien. Vous donnerez à votre programme le nom que vous souhaitez.
Mais choisissez de préférence un nom qui explique ce que fait la classe.

Explication de L’Exemple Zero :

Un programme Java est un ensemble de classes. Au moins une classe par programme.

ligne 1 = déclaration de la classe.

En général, on déclare une classe java à l'aide de 3 mots :

----le premier mot est l' un des mots suivants : public ou private ou protected ou abstract. En tant que débutant,
contentez-vous du mot public. Les explications, ce sera pour plus tard.

----le deuxième mot est forcément le mot class (attention, pas de "e" à la fin de class). C'est ce mot qui indique
que nous déclarons une classe.

----Le troisième mot est le nom de la classe

Lorsqu' un programme java ne contient qu' une seule classe (exemple zéro), alors, le nom de la classe est le
nom du programme.
Le nom de la classe indique donc ce que fait le programme.

Le nom d'une classe commence toujours par une lettre majuscule. C'est une convention, pas une obligation.

Lorsque le nom d'une classe est composée de plusieurs mots, la première lettre de chaque mot est en majuscule.
Cela facilite la lecture et la compréhension du nom.

ATTENTION !!! il n' y a pas d' espace dans le nom d' une classe. Interdit en java.

On peut séparer chaque mot d'un nom par le caractère underscore qui se trouve sous le chiffre 8 sur un clavier
AZERTY. Par exemple, la classe de l' exemple zéro peut s' écrire : Qui_ne_fait_rien . Dans ce cas, on n'est pas
obligé de commencer chaque mot par une lettre majuscule. Sauf le premier (convention).

Après avoir déclaré votre classe, vous mettez sous la première lettre de cette déclaration, une accolade ouverte (
ligne 2). Ensuite, sous l'accolade ouverte, vous mettez une accolade fermée (ligne 9). Puis entre les deux
accolades, vous mettez de l'espace afin d'y mettre le contenu de la classe.

ATTENTION !!! Les accolades, ça marche toujours par paire. Une ouverte pour une fermée. Sinon, le
compilateur envoie un message d'erreur.

Le contenu de notre classe se trouve entre les lignes 4 et 7.

La ligne 4 est la déclaration d'une fontion. Et pas n' importe quelle fonction. C'est la fonction main.

main est un mot anglais qui veut dire principal. La fonction main est donc la fonction principale. Pourquoi
principale ? Parce que c'est à l'intérieur de cette fonction, entre ses accolades ouverte (ligne 5) et fermée (ligne
7) que se trouvent toutes les instructions du programme. Ici, ce contenu est vide. Vous voyez bien qu'il n'y a
aucune instruction dans cette fonction main. Ce qui veut dire que le programme ne fait rien du tout. D' où le
nom du programme qui est aussi le nom de la classe. QuiNeFaitRien

Plus tard, je vous dirai comment déclarer vos propres fonctions et comment les créer.
Sachez pour l'instant que la fonction principale (main) se déclare toujours comme à la ligne 4.
Sachez dès maintenant que dans la déclaration d'une fonction, le nom d'une fontion est
toujours suivie d'un couple de parenthèses. Une parenthèse ouverte et une fermée à l'intérieur desquelles on
trouve éventuellement zéro, un ou plusieurs paramètres.

Les prochains exemples contiendront au moins une instruction dans la fonction main().

Remarquez les parenthèses vides qui suivent le mot main dans la ligne ci-dessus.
A partir de maintenant, chaque fois que je parlerai d'une fonction en écrivant son nom, je ferais suivre un
couple de parenthèses pour que vous remarquiez tout de suite que je suis entrain de parler d'une fonction.

Après avoir défini votre classe, vous l'enregistrerez sous l'extension .java. Par exemple, QuiNeFaitRien.java ou
Qui_ne_fait_rien.java Après l'avoir enregistré, vous compilerez votre programme puis vous l'exécuterez.

La compilation consiste à vérifier que votre code est bien écrit. Si tel n'est pas le cas, un ou plusieurs messages
d'erreur vous sont affichés afin que vous corrigiez.

L’exécution, comme son nom l indique, consiste à exécuter le programme. Sachez qu'une erreur peut aussi
survenir à l exécution. Mais en général, ce sont des erreurs moins graves.

Si vous compilez puis exécutez ce programme, il ne se passera rien du tout.

Normal, le programme ne comporte aucune instruction.

Autre chose importante dans un programme Java, comme dans tout langage de programmation : les
commentaires.

Lorsqu'on écrit un programme de quelques lignes, pas besoin de commentaires. Mais imaginez un programme
de 1000 lignes ou plus. On peut avoir besoin de regrouper certaines instructions en un bloc. On peut alors écrire
un commentaire au début de ce bloc. Histoire de se souvenir de quoi il est question. Pour que ces
commentaires ne soient pas interprétés comme des instructions, il est indispensable de les encadrer par des
caractères spécifiques qui sont :
// un commentaire sur une ligne.
/* un commentaire sur plusieurs lignes */

Exemple de commentaire sur une seule ligne

EXEMPLE ZERO : Architecture minimale

1. public class QuiNeFaitRien

2. {
3. // fonction principale
4. public static void main (String [] args)
5. {
6.
7. }
8.
9. }
Sur la ligne 3, j'ai mis un commentaire qui explique que ce qui suit est la fonction principale. Très court, ce
commentaire se met sur une seule ligne.
Mais si je mets un commentaire plus long, il est possible que je mette sur 2 lignes.

EXEMPLE ZERO : Architecture minimale

1. public class QuiNeFaitRien

2. {
3. /* fonction principale Parce que c'est à l'intérieur de cette fonction,
4. entre ses accolades ouvertes que se trouvent toutes les instructions du
programme. */
5. public static void main (String [] args)
6. {
7.
8. }
9.
10. }
Bien entendu, tout programmeur en Java, aussi débutant soit-il, sait où se trouve la fonction principale et sa
signification.
Il s'agissait ici d'illustrer les 2 types de commentaires.

Pour un commentaire sur plusieurs lignes, moi, je préfère ceci :

/*
première ligne de commentaire
deuxième ligne
troisième ligne
*/

Je n'écris rien sur les lignes contenant respectivement /* et */

 2. La fonction System.out.print( )
(Comment afficher une information à l'écran)

En java, comme en tout langage de programmation, il est nécessaire, d’afficher de temps en temps une ou
plusieurs informations à l écran (ordinateur, portable, caluclatrice, etc...). Ceci a au moins une importance.
Informer l'utilisateur du programme à quelle étape se trouve le programme.

En java, on utilise pour cela la fonction System.out.print(). Remarquez la seule lettre majuscule, le S. Le nom
d'une classe commence toujours par une lettre majuscule. La véritable fonction est print( ). Et elle appartient à
la classe System.

La fonction System.out.print() est une fonction prédéfinie par le langage java.

EXEMPLE 1 :

1. public class Afficher1

2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("bonjour");
7. }
8.
9. }

Enregistrez sous Afficher1.java

Compilez puis exécutez. Il sera affiché à l'écran :

bonjour.

La fonction System.out.print() affiche toujours ce qui se trouve entre ses parenthèses.

Dans l'exemple 1, on trouve dans les parenthèses de cette fonction, une chaine de caractères.

Un caractère, c'est tout ce que vous tapez sur votre clavier et qui apparaît à l'écran de votre ordinateur : lettre,
chiffre, signe de ponctuation, etc ...
Attention, les touches alt, ctrl ou maj ne font pas apparaître un caractère à l'écran. En revanche, la barre
d'espace fait apparaître un caractère à l'écran. C'est le caractère espace. Donc l'espace est aussi un caractère. On
le voit surtout quand il sépare 2 mots.

Une chaine de caractères est un ensemble de caractères qui se suivent. Pour que Java considère cette suite
comme une chaine de caractères à part entière, il faut l'entourer de doubles guillemets.

Exemple : "bonjour". S'il n' y a pas de doubles guillemets, java considère que c' est une variable et non une
chaine de caractères. Pensez-y !

La fonction System.out.print() n'affiche pas que les chaines de caractères. Elle affiche aussi des nombres,
entiers ou décimaux. Et bien d’autres choses encore.

La ligne 6 est une instruction. En java, toute instruction se termine par un point virgule.
EXEMPLE 2:

1. public class Afficher2

2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print(25);
7. }
8.
9. }
Compilez puis exécutez. Il sera affiché à l'écran, le nombre 25.

Pourquoi n'y a-t-il pas de doubles guillemets qui entourent le nombre 25 ? Parce que justement c'est un nombre
et pas une chaine de caractères.

Quelle différence dans l'affichage me diriez-vous ? Aucune. Par contre, java fera une grande différence entre les
deux lorsqu' il s'agira d'effectuer des opérations mathématiques. L'exemple suivant.
EXEMPLE 3 :

1. public class Afficher3

2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print(25 + 25);
7. }
8.
9. }
Compilez pui exécutez. Il sera affiché à l'écran, le nombre 50.

Lorsque Java voit une opération mathématique dans les parenthèses de la fonction System.out.print(), java
effectue d' abord l'opération, puis affiche le résultat. D'où 50 affiché à l'écran.
EXEMPLE 4 :
1. public class Afficher4
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("25" + 25);
7. }
8.
9. }
Compilez pui exécutez. Il sera affiché à l'écran : 2525.

Lorsque Java voit l'opération "25" + 25 dans les parenthèses de la fonction System.out.print(), java effectue
d'abord l' opération, puis affiche le résultat. Mais ici, l'opération mathématique se fait entre une chaine de
caractères et un nombre entier. Le résultat, c'est forcément une chaine de caractères. Car java transforme
d'abord le nombre entier avant d'effectuer l'addition. Et l'addition de deux chaines de caractères donne toujours
une chaine de caractères dont le contenu est l'ensemble des caractères des deux chaines.
Exemple : "para" + "pluie" = "parapluie". De même, "25" + 25 donne d' abord "25" + "25" = "2525".
EXEMPLE 5:

1. public class Afficher5

2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("Bonjour");
7. System.out.print("monsieur");
8. }
9.
10. }
Compilez puis exécutez, il sera affiché ceci : Bonjourmonsieur.

Pourquoi ? Parce que la fonction System.out.print() affiche Bonjour. Puis place le curseur juste après la
dernière lettre du mot. Donc, juste après r. (ligne 6). Puis Cette fonction affiche le mot monsieur. Et
naturellement, commence juste après le r de Bonjour.

Pour remédier à la situation, deux solutions : mettre un caractère espace entre le r de bonjour et le double
guillemet ou mettre cet espace entre le double guillemets et le m de monsieur.

EXEMPLE 6:
1. public class Afficher6
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("Bonjour ");
7. System.out.print("monsieur");
8. }
9.
10. }

EXEMPLE 7 :
1. public class Afficher7
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("Bonjour");
7. System.out.print(" monsieur");
8. }
9.
10. }
Compilez puis exécutez chacun des exemples 6 et 7, il sera affiché ceci : Bonjour monsieur.

Mais on peut aussi résoudre le problème plus simplement en mettent "Bonjour monsieur" dans les parenthèses
d'un seul System.out.print()

EXEMPLE 8
1. public class Afficher8
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("Bonjour monsieur");
7. }
8.
9. }

Vous voulez afficher Bonjour et monsieur sur deux lignes différentes ? Dans ce cas, vous utiliserez une autre
variante de la fonction System.out.print() . Elle s'appelle System.out.println().
ln = abréviation de line qui veut dire ligne.
La fonction System.out.println() affiche ce qui se trouve dans les parenthèse, comme son homologue. Mais en
plus, elle place le curseur, non pas derrière le dernier caractère, mais sur la ligne suivante. De sorte que si vous
avez une autre instruction d'affichage, elle se fera forcément sur la ligne suivante.

EXEMPLE 9
1. public class Afficher9
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.println("Bonjour");
7. System.out.print("monsieur");
8. }
9.
10. }
Compilez, puis exécuter, il sera affiché :
Bonjour
monsieur

On peut aussi réussir ça en utilisant la chaine de caractère \n.

EXEMPLE 10
1. public class Afficher10
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("Bonjour\nmonsieur");
7. }
8.
9. }
Compilez, puis exécuter, il sera affiché :
Bonjour
monsieur

la fonction System.out.print() se met à afficher le mot Bonjour. Puis lorsqu' elle rencontre \n, elle passe sur la
ligne suivante. \n permet donc de mettre le curseur sur la ligne suivante.

Attention, le symbole \n n'a de sens que s'il se trouve entre guillemets.

Par exemple System.out.print("bonjour" + \n) ne veut rien dire du tout. La compilation renverra forcément
un message d'erreur.

Ce fameux caractère \ est très intéressant en java. Regardez plutôt l'exemple suivant et suivez les explications.
EXEMPLE 11 :
1. public class Afficher11
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("c:\\repertoire\\sous-repertoire");
7. }
8.
9. }
Compilez, puis exécuter, il sera affiché ceci : c:\repertoire\sous-repertoire

Lorsque java rencontre le caractère \, il regarde aussi le caractère suivant. Selon la nature de ce caractère, il
donne un sens. \\ veut dire afficher \.
Si le caractère suivant est n, ça veut dire, mettre le curseur sur la ligne suivante.
SI c'est le caractère t, ça veut dire, tabulation.
EXEMPLE 12
1. public class Afficher12
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.println("1\t1\t1");
8. System.out.println("2\t2\t2");
9. System.out.println("3\t3\t3");
10. System.out.println("4\t4\t4");
11. System.out.println("5\t5\t5");
12. }
13.
14. }
Compilez, puis exécuter, il sera affiché ceci :

1 1 1
2 2 2
3 3 3
4 4 4
5 5 5

Explications :
Java affiche le chiffre1. Puis affiche un espace de tabulation. Puis affiche à nouveau 1. Et à nouveau la
tabulation et enfin le chiffre 1.
Puis java met le curseur à la ligne suivante. Souvenez-vous du ln dans System.out.println().
Même chose pour les lignes suivantes.

Si vous estimez que l'espace de tabulation n'est pas assez grand, vous pouvez le doubler, même le tripler.
Exemple de double tabulation ci-dessous :

EXEMPLE 13 :
1. public class Afficher13
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.println("1\t\t1\t\t1");
8. System.out.println("2\t\t2\t\t2");
9. System.out.println("3\t\t3\t\t3");
10. System.out.println("4\t\t4\t\4");
11. System.out.println("5\t\t5\t\t5");
12. }
13.
14. }
Compilez, puis exécuter, il sera affiché ceci :

1 1 1
2 2 2
3 3 3
4 4 4
5 5 5

Explications :
Java affiche le chiffre1. Puis affiche 2 espaces de tabulation. Puis affiche à nouveau 1. Et à nouveau la double
tabulation et enfin le chiffre 1.
Puis java met le curseur à la ligne suivante. Souvenez-vous du ln dans System.out.println().
Même chose pour les lignes suivantes.

Attention ! ! ! L' espace de tabulation que vous voyez sur cet écran ne sera pas forcément le même sur l' écran
de votre environnement de programmation. C' est un espace dont on peut programmer la largeur. Mais pour
vous débutants, n' y pensez pas dans l' immédiat. Ce n' est pas le plus important.

Le fait d'afficher à l'aide du caractère \ se dit en java, parser. Autre exemple de parsing ci-dessous :
EXEMPLE 14
1. public class Afficher14
2. {
3.
4. public static void main (String [] args)
5. {
6. System.out.print("il a dit : \"mangez\".");
7.
8. }
9.
10. }

Compilez, puis exécuter, il sera affiché ceci : il a dit : "mangez"

Explications :
Comme je vous l'ai dit plus haut, la fonction System.out.print() affiche ce qui se trouve entre les doubles
guillemets. Mais si on veut afficher les doubles guillemets eux-même, comment faire ?... Le parsing,
évidement. D' où le \". De même que \\ affiche le \, de même le \" affiche le "
 3. Les variables (1)
(Les types primitifs et les constantes : déclaration et affectation)

Lorsque vous donnez votre numéro à la sécurité sociale, on retrouve vos nom, prénom(s), âge, etc... Parce que
ce programme qui se trouve dans leurs ordinateurs a besoin de stocker ces informations. Ces informations sont
contenues dans ce qu'on appelle des variables. Ces dernières ont pour valeurs, des nombres (entiers ou
décimaux), des mots, des dates de naissance, des fichiers, et d'autres informations moins simples que nous
verrons plus tard : des objets (au sens de la programmation orientée objet).

Dans ce chapitre, nous nous contenterons de voir les variables de type primitif qui sont : byte, short, int, long,
float, double, char, boolean et String. Encore que le dernier peut être utilisé aussi bien en type primitif qu'en
type Objet.

Programmez sans variables est une mission plutôt impossible.

EXEMPLE 1 :
1. public class Variables1
2. {
3.
4. public static void main (String [] args)
5. {
6. age = 40;
7. }
8.
9. }
Compilez ce programme, un message d'erreur sera affiché. Ce message sera :

Variables1.java:9: cannot find symbol

symbol : variable age
location: class Testeur
age = 40;
^
1 error

Explications :
Java ne comprend pas un terme. Ce terme est la variable age qui se trouve dans la classe Variables1.java
Ce message est normal. En Java, quand on utilise une variable, on doit d' abord la déclarer. Et on déclare une
variable grâce à au moins deux mots : le nom de la variable, précédé de son type.
Java est en effet un langage de programmation fortement typé. On ne met pas n' importe quelle valeur dans
n'importe quelle variable. Cela permet d'éviter des erreurs.

En Java, on distingue 2 grands groupes de types de variables.

Les types primitifs encore appelés types de bases et les types dits de classe encore appelés types objets, au sens
de la programmation orientée objet. Nous verrons les types objet plus tard.

Les types primitifs sont classés en 4 groupes :

Le type nombre entier qui contient 4 sous-types :

Le type byte dont les valeurs sont comprises entre - 128 et + 127 ...
Le type short dont les valeurs sont comprises entre - 32 768 et + 32 767...
Le type int dont les valeurs sont comprises entre - 2 147 483 648 et + 2 147 483 647 et enfin
Le type long dont les valeurs sont comprises entre - 9 223 372 036 854 775 808 et + 9 223 372 036 854
775 807
Avant de parler des autres types de base, un petit exemple :
EXEMPLE 2 :
1. public class Variables2
2. {
3.
4. public static void main (String [] args)
5. {
6. byte age;
7. age = 40;
8. System.out.print(age);
9. }
10.
11. }
Compilez puis exécutez ce programme, il sera affiché :
40

Expliquons :
Sur la ligne 6, nous avons déclaré la variable age comme étant de type byte. Donc, un nombre entier dont la
valeur est comprise entre - 128 et + 127. Sur la ligne 7, on a mis la valeur 40 dans la variable age. On dit aussi
qu'on a affecté la valeur 40 à la variable age. Sur la ligne 8, vous l'avez deviné, on demande à Java d'afficher la
variable age.

EXEMPLE 4 :
1. public class Variables4
2. {
3.
4. public static void main (String [] args)
5. {
6. byte age = 40;
7. System.out.println(age);
8. short nombreEleves = 12574;
9. System.out.println(nombreEleves);
10. int populationFrance = 65254897;
11. System.out.println(populationFrance);
12. long distanceExoPlanete = 12425369875489624;
13. System.out.println(distanceExoPlanete);
14.
15. }
16. }
Compilez puis exécutez ce programme, il sera affiché :
40
12574
65254897
12425369875489624

Expliquons :
La ligne 6 : déclaration et affectation d' une valeur à une variable.
La ligne 7 : affichage de la valeur de cette variable.
Même raisonnement pour les lignes 8 et 9, puis 10 et 11, puis 12 et 13.
Sachez que dans la pratique, pour ce qui est des variables de type primitifs, déclaration et affectation vont
toujours ensemble.
Le nom d'une variable peut commencer par une lettre (miniscule obligatoirement) ou par le caractère
underscore _ (sur la même touche que 8 sur le clavier azerty). Personnellement, je préfère la lettre miniscule.
Dans le cas où le nom d'une variable est un ensemble de mots, la première lettre des autres mots doit être en
majuscules, ceci afin de différencier les mots et faciliter ainsi la lecture.
EXEMPLE 5 :
1. public class Variables5
2. {
3.
4. public static void main (String [] args)
5. {
6. byte age = 40;
7. System.out.println("age = " + age);
8. short nombreEleves = 12574;
9. System.out.println("nombreEleves = " + nombreEleves);
10. int populationFrance = 65254897;
11. System.out.println("populationFrance = " + populationFrance);
12. long distanceExoPlanete = 12425369875489624;
13. System.out.println("distanceExoPlanete = " + distanceExoPlanete);
14.
15. }
16. }
Compilez puis exécutez ce programme, il sera affiché :
age = 40
nombreEleves = 12574
populationFrance = 65254897
distanceExoPlanete = 12425369875489624

C'est mieux ça ? Evidement

ligne 7 : Java affiche ce qui se trouve entre les doubles guillemets, puis affiche le contenu de la variable
préalablement déclarée et affectée ligne 6
Même raisonnement pour les autres affichages.
Autre chose sur les nombres entiers. Si vous ne connaissez pas quel type choisir, parce que évidement vous ne
connaissez pas l'échelle des valeurs, choisissez le type int. C'est toujours le type qu'on choisit par défaut. Même
java le choisit par défaut.

Maintenant, voyons les autres types primitifs.

EXEMPLE 6 :
1. public class Variables6
2. {
3.
4. public static void main (String [] args)
5. {
6. char lettre = 't';
7. System.out.println("lettre = " + lettre);
8. String nom = "DUPONT";
9. System.out.println("nom = " + nom);
10.
11. }
12. }
Compilez puis exécutez ce programme, il sera affiché :
lettre = c
nom = DUPONT

Lorsque votre variable ne doit contenir qu' un seul caractère, et que cela ne doit pas changer au cours du
programme, vous avez affaire à une variable de type char. Si vous essayez de mettre plus d'un caractère dans
une variable de type char, un message d'erreur sera affiché à la compilation. Même chose si vous essayez d'y
mettre zéro caractère. Attention, Le caractère espace n'est pas zéro caractère.

Donc, char c = ' '; est acceptable en Java. Pas char c = '';
Alors que le type String lui accepte zéro caractère. String z = ""; est correct en Java.

Pour le type String, c'est tout simplement la chaine de caractères.

Sachez que le type String n' est pas un type de base, un type primitif de java. Mais plutôt un type Objet. Mais si
on en parle ici, c'est parce qu'il a une petite particularité. Une variable de type String peut être affectée comme
un type primitif, avec le signe égal (=). Alors que les types Objets sont toujours affectés par le mot clé new .
Nous le verrons plus tard en Programmation Orientée Objet.

Sachez pour finir avec ce type que vous pouvez mettre un nombre de caractères indifférents dans le type String.
Y compris zéro caractère.
EXEMPLE 7 :
1. public class Variables7
2. {
3.
4. public static void main (String [] args)
5. {
6. float tva = 20.6f;
7. System.out.println("tva = " + tva);
8. double tauxLivret = 2.5;
9. System.out.println("tauxLivret = " + tauxLivret);
10.
11. }
12. }

Compilez puis exécutez ce programme, il sera affiché :

tva = 20.6
tauxLivret = 2.5

Les types float et double sont des types nombres décimaux. En java, on dit surtout nombres réels ou nombres à
virgule flottante. le type float est un type dont les valeurs sont comprises entre - 1.4 * 10-45 et + 3.4 * 10 + 38
Le type double a ses valeurs comprises entre - 4.9 * 10- 324 et 1.7 * 10+ 308
Le caractère * est le signe de la multiplication en Java
Si vous ne connaissez pas l' échelle de valeurs de la variable de type nombre réel que vous manipulez, préférez
le type double. C'est aussi le type que Java choisit par défaut.
La lettre f qui termine la valeur de la variable de type float permet de préciser qu'il est bien question de type
float. Si la lettre n'y est pas mentionnée, alors on a affaire au type double. Essayer de mettre une valeur de type
double dans une variable de type float, un message d'erreur s'affiche. Java n'aime pas ça.

EXEMPLE 8 :
1. public class Variables8
2. {
3.
4. public static void main (String [] args)
5. {
6. boolean situation1 = true;
7. System.out.println("situation1 = " + situation1);
8. boolean situation2 = false;
9. System.out.println("situation2 = " + situation2);
10.
11. }
12. }

Compilez puis exécutez ce programme, il sera affiché :

situation1 = true
situation2 = false

Les variables de type boolean n'ont que deux valeurs possibles. Si une situation est vraie, la valeur est true.
Dans le cas contraire, la valeur est false. On ne peut pas affecter une autre valeur dans une variable de type
boolean. Si vous essayez, un message d'erreur à la compilation
Dans la pratique, vous n'aurez pas à afficher la valeur d'une variable de type boolean. Vous exploiterez cette
valeur de façon implicite dans des structures conditionnelles.

Par exemple, si x est supérieur à y, alors afficher x. Sinon, affichez y. Evidement, vous utiliserez le langage
Java pour cela. Si x est effectivement supérieur à y, la situation est vraie. Fausse dans le cas contraire.

EXEMPLE 9 :
1. public class Variables9
2. {
3.
4. public static void main (String [] args)
5. {
6. final int NOMBRE = 25;
7. System.out.println("NOMBRE = " + NOMBRE);
8.
9 . }
10. }

Compilez puis exécutez ce programme, il sera affiché :

NOMBRE = 25

Ligne 6 déclaration et affectation d'une variable. Comme vous le savez déjà. Mais il y a quelque chose en plus.
Le mot final. Ce mot a une signification particulière en Java. Cela veut dire que la variable NOMBRE est
constante. Donc la valeur de ce nombre ne doit pas varier au cours du programme. Si tel devait être le cas,
à la compilation, un message d'erreur s'afficherait.
Remarquez aussi le nom de la variable. Toutes les lettres sont en majuscules. En Java, il est conseillé (pas une
obligation) d'écrire le nom d'une variable constante toute en majuscule.

EXEMPLE 10 :
1. public class Variables10
2. {
3.
4. public static void main (String [] args)
5. {
6. final int NOMBRE = 25;
7. NOMBRE = 33;
8.
9 . }
10. }

Compilez ce programme. Et vous aurez un message d'erreur qui sera :

cannot assign a value to a final variable NOMBRE

Ce qui veut dire : je ne peux pas attribuer une valeur à une variable final. En effet, une variable déclarée avec le
mot clé final est une constante. Donc, impossible de changer sa valeur.

Le même message d'erreur sera affiché, même dans le cas ou vous essayez de mettre la valeur 25 dans la
variable NOMBRE. Etonnant ? pas vraiment. Lorsque vous donnez une nouvelle valeur à une variable, cette
nouvelle valeur vient chasser l'ancienne. Ce qui veut dire que l'action de mettre une valeur dans la variable est
quand même réalisée. Le compilateur JAVA juge l'action de vouloir mettre une valeur dans une variable
constante. Ce qui, pour lui, est anormal. Le compilateur ne cherche pas à comparer la nouvelle valeur et
l'ancienne.
EXEMPLE 11 :
1. public class Variables11
2. {
3.
4. public static void main (String [] args)
5. {
6. int for = 25;
7.
8.
9 . }
10. }

Compilez ce programme et un message d'erreur vous signalera que l'instruction n'en est pas une (not a
statement sera affiché.)

Pourquoi ? parce que le nom de la variable est ici un mot clé java. Ce mot (for) est toujours suivi d'une paire de
parenthèses. Ce qui n'est pas le cas ici. Donc, le compilateur considère que ce n'est pas une instruction (a
statement). for est un mot clé du langage JAVA.

En effet, Un mot-clé est tout simplement un mot qui a été réservé pour une utilisation spéciale par le langage.
Vous ne pouvez donc pas employer des mots-clés comme noms de variable, ou nom de classe.

Ces mots sont :

abstract - assert - boolean - break - byte - case - catch - char class - const - continue - default - do - double
- else - extends - false - final - finally - float - for - goto - if - implements - import - instanceof - int -
interface - long - native - new - null - package - private - protected - public - return - short - static -
strictfp - super - switch - synchronized - this - throw - throws - transient - true - try - void - volatile -
while
EXEMPLE 12 :
1. public class Variables12
2. {
3.
4. public static void main (String [] args)
5. {
6. int 1nombre = 25;
7.
8.
9 . }
10. }

Compilez ce programme et un message d'erreur vous signalera que l'instruction n'en est pas une instruction (not
a statement) sera affiché.
Pourquoi ? Parce qu'ici le nom de la variable commence par un chiffre.

Le nom d'une variable ou de quoique ce soit d' ailleurs en java, ne doit jamais commencer par un nombre.

EXEMPLE 13 :
1. public class Variables13
2. {
3.
4. public static void main (String [] args)
5. {
6. int nombre1 = 25; int nombre2 = 11; int nombre3 = 52;
7. System.out.println("nombre1 = " + nombre1);
8. System.out.println("nombre2 = " + nombre2);
9 . System.out.print("nombre3 = " + nombre3);
10. }
11. }
Compilez puis exécutez ce programme, il sera affiché :
nombre1 = 25
nombre1 = 11
nombre1 = 52
Ligne 6 : déclaration de la variable nombre1 et affectation de la valeur 25 à cette variable. Même chose pour
nombre2 avec valeur 11 et même chose pour nombre3 avec valeur 52.
Ligne 7 : affichage de la chaine de caractères nombre1 = suivi de la valeur de la variable nombre1
Même explication pour nombre2 (ligne8) et nombre3 (ligne9).

Jusqu'ici, cet exemple ne vous apprend rien de nouveau à priori. Mais reprenez ce programme et changez
seulement la ligne 6 en ceci :
int nombre1 = 25, nombre2 = 11, nombre3 = 52;

Après compilation et exécution, vous aurez le même résultat.

Explications :
En Java, on peut déclarer plusieurs variables de même type en écrivant une seule fois le mot-clé représentant le
type. A condition de mettre une virgule au lieu d'un point virgule après chaque variable déclarée.

int a, b, c, d; équivaut à int a; int b; int c; int d;

int a = 1, b = 5, c = 21; équivaut à int a = 1; int b = 5; int c = 21;

Notez bien les endroits où l'on utilise seulement la virgule.

int a = 31; b = 25; --> à la compilation, message d'erreur. Car b = 5 n'est pas reconnu par Java. Seul a est
reconnu comme une variable de type int.
Correction : int a = 31, b= 25; ou int a = 31; int b = 25;

Evidement, int a = 33, byte b = 4; est une fausse déclaration qui sera sanctionnée par le compilateur en vous
envoyant un message d'erreur.
En effet, byte et int sont peut-être deux variables de type nombre entier. Mais on ne peut pas les déclarer en
séparant par une simple virgule.