Les variables et les opérateurs

Les variables et les opérateurs

Nous y voilà. Encore un chapitre barbant... Mais celui-là aussi est nécessaire, et je dirais même vital !
En Java, comme dans beaucoup de langages de programmation, avant d'utiliser une variable, nous devons d'abord définir ce qu'elle va contenir.

T'es bien gentil, mais c'est quoi, une variable ?

Oups ! Désolé ! Je parle, je parle et j'oublie l'essentiel... Une variable, c'est ce qui va nous permettre de stocker des informations de toute sorte (chiffres, résultats de calcul, des tableaux, des renseignements fournis par l'utilisateur...). Bref, vous ne pourrez pas faire de programme sans variables. Et comme je viens de vous le dire, et j'insiste là dessus, il faut à tout prix définir ce que nos variables vont contenir avant de les utiliser.

Une déclaration de variable se fait comme suit :

<Type de la variable> <Nom de la variable> ;

Cette opération se termine toujours par un ";" (comme toutes les instructions de ce langage) ;
ensuite, on l'initialise en rentrant une valeur.

Bon. Assez de bla-bla, on y va. (Décidément, moi, les rimes en ce moment...)

Sommaire du chapitre :

Les différents types de variables
Les opérateurs arithmétiques
Les conversions, ou "cast"
Astuce d'Eclipse

Les différents types de variables

Bon. En Java, nous avons deux type de variables :

des variables de type simple ou "primitif",
des variables de type complexe ou encore des objets.

Ce qu'on appelle des types simples, ou types primitifs, en Java ce sont tout bonnement des nombres entiers, des nombres réels, des booléens ou encore des caractères. Mais vous allez voir qu'il y a plusieurs façons de déclarer certains de ces types.

Commençons par les variables de type numérique

- Le type byte (1 octet) peut contenir les entiers entre -128 et +127.
Ex. :
Code : Java

1 2	byte temperature; temperature = 64;

- Le type short (2 octets) contient les entiers compris entre -32768 et +32767.
Ex. :
Code : Java

1 2	short vitesseMax; vitesseMax = 32000;

- Le type int (4 octets) va de -2*10⁹ à 2*10⁹ (2 et 9 zéros derrière... ce qui fait déjà un joli nombre).
Ex. :
Code : Java

1 2	int temperatureSoleil; temperatureSoleil = 15600000;

C'est en kelvins...
- Le type long(8 octets) de -9*10¹⁸ à 9*10¹⁸ (encore plus gros...).
Ex. :
Code : Java

1 2	long anneeLumiere; anneeLumiere = 9460700000000000;

- Le type float (4 octets) correspond à des nombres avec virgule flottante.
Ex. :
Code : Java

1 2	float pi; pi = 3.141592653f;

ou encore
Code : Java

1 2	float nombre; nombre = 2.0f;

Vous remarquerez que nous ne mettons pas de virgule mais un point ! Et vous remarquerez aussi que même si le nombre en question est rond, on met tout de même .0 derrière celui-ci !

- Le type double (8 octets) est identique à float, si ce n'est qu'il contient un nombre plus grand derrière la virgule.
Ex. :
Code : Java

1 2	double division; division = 0.333333333333333333333333333333333333333333334;

Nous avons aussi des variables stockant du caractère

- Le type char contient UN caractère stocké entre de simples quotes ' ' comme ceci...
Ex. :
Code : Java

1 2	char caractere; caractere = 'A';

Nous avons aussi le type booléen

- Le type boolean qui lui contient true (vrai) ou false (faux).
Ex. :
Code : Java

1 2	boolean question; question = true;

Et aussi le type String

- Celle-ci correspond à de la chaîne de caractères.
Ici, il ne s'agit pas d'une variable mais d'un objet qui instancie une classe qui existe dans Java ; nous pouvons l'initialiser en utilisant l'opérateur unaire new() dont on se sert pour réserver un emplacement mémoire à un objet (mais nous reparlerons de tout ceci dans la partie deux, lorsque nous verrons les classes), ou alors lui affecter directement la chaîne de caractères.
Vous verrez que celle-ci s'utilise très facilement et se déclare comme ceci :
Ex. :
Code : Java

String phrase;

phrase = "Titi et gros minet";

//Deuxième méthode de déclaration de type String

String str = new String();

str = "Une autre chaîne de caractères";

//La troisième

String string = "Une autre chaîne";

//Et une quatrième pour la route

String chaine = new String("Et une de plus ! ");

Attention : String commence par une majuscule ! Et lors de l'initialisation, on utilise ici des doubles quotes " " .

En fait, String n'est pas un type de variable mais un objet.
Notre variable est "un objet", on dit aussi "une instance", ici, une instance de la classe String. Nous y reviendrons lorsque nous aborderons les objets.

On te croit sur parole, mais pourquoi String commence par une majuscule et pas les autres ?

C'est simple. Il s'agit d'une convention de nommage.
En fait, c'est une façon d'appeler nos classes, nos variables, etc. Il faut que vous essayiez de respecter cette convention au maximum. Cette convention, la voici :

tous vos noms de classes doivent commencer par une majuscule !
tous vos noms de variables doivent commencer par une minuscule.
Si un nom de variable est un nom composé, celui-ci commence par une minuscule et son composé par une majuscule. Et ce, sans séparation.
Tout ceci sans accent ! !

Je sais que la première classe que je vous ai demandé de créer ne respecte pas cette convention, mais je ne voulais pas vous dire ça à ce moment-là... Donc, à présent, je vous demanderai de ne pas oublier ces règles !
Sinon ! Châtiment corporel.
Voici quelques exemples de noms de classes et de variables :
Code : Java

public class Toto{}

 public class Nombre{}

 public class TotoEtTiti{}

 String chaine;

 String chaineDeCaracteres;

 int nombre;

 int nombrePlusGrand;

 //...

Donc, pour en revenir au pourquoi du comment, je vous ai dit que les variables de type String sont des objets. Les objets sont définis par une ossature (un squelette) qui est en fait une classe. Ici, nous utilisons un objet String qui est défini dans une classe qui s'appelle "String" ; c'est pourquoi String à une majuscule et pas int, float... qui eux ne sont pas définis par une classe.

Pfiou ! Ça en fait des choses à retenir d'un coup ! Mais je ne vous cache pas que les deux premiers types de variables ne sont pas trop utilisés...

Chose importante : veillez à bien respecter la casse (majuscules et minuscules) car une déclaration de CHAR à la place de char ou autre chose provoquera une erreur, tout comme une variable de type string à la place de String !

Alors faites bien attention lors de vos déclarations de variables... Sinon une petite astuce quand même, enfin deux plutôt ! On peut très bien compacter la phase de déclaration et d'initialisation en une seule phase ! Comme ceci :
Code : Java

int entier = 32;

float pi = 3.1416f;

char carac = 'z';

String mot = new String("Coucou");

Et lorsque nous avons plusieurs variables d'un même type, nous pouvons compacter tout ceci en une déclaration comme ceci :
Code : Java

1	int nbre1 = 2, nbre2 = 3, nbre3 = 0;

Ici, toutes les variables sont des entiers et toutes initialisées.

Bon, t'es bien mignon, mais on code quand, nous ?

Minute papillon ! On va y arriver !
Mais avant, nous avons encore quelque chose de très important à voir pour pouvoir travailler sur et avec nos variables :
Les opérateurs arithmétiques

Les opérateurs arithmétiques

Ceci est notre avant dernière ligne droite avant de commencer à coder ! Et après, vous regretterez le temps où vous n'aviez pas à vous creuser la tête !!

Bon, allez ! Je vois bien que vous brûlez d'impatience, alors on va y aller tout de suite.

Les opérateurs arithmétiques

Ce sont ceux que l'on apprend à l'école primaire...

+ permet d'ajouter deux variables numériques (mais aussi de concaténer des chaînes de caractères ! Ne vous inquiétez pas, on aura l'occasion d'y revenir).

- permet de soustraire deux variables numériques.
* permet de multiplier deux variables numériques.
/ Permet de diviser deux variables numériques.(mais je crois que vous aviez deviné).
% permet de renvoyer le reste de la division de deux variables de type numériques, cet opérateur s'appelle le modulo.

Quelques exemples de calcul

Code : Java

int nbre1, nbre2, nbre3;//déclaration des variables

nbre1 = nbre2 = nbre3 = 0;//initialisation

nbre1 = 1 + 3;         // ici nbre1 vaut 4

nbre2 = 2 * 6;         // ici nbre2 vaut 12

nbre3 = nbre2 / nbre1;     //ici nbre3 vaut 3

nbre1 = 5 % 2;         //ici nbre1 vaut 1 car 5 = 2 * 2 + 1

nbre2 = 99 % 8;        //ici nbre2 vaut 3 car 99 = 8 * 12 + 3

nbre3 = 6 % 3;         //et là, nbre3 vaut 0 car la division n'a aucun reste

Ici, nous voyons bien que nous pouvons affecter des opérations sur des nombres à nos variables mais aussi affecter des opérations sur des variables de même type !!

Je me doute bien que le modulo est assez difficile à assimiler. Voici une utilisation assez simple : Pour déterminer si un entier est pair, il suffit de voir si cet entier modulo 2 renvoie 0.

Maintenant, quelque chose que les personnes qui n'ont jamais programmé ont du mal à assimiler. Je garde la même déclaration de variable que ci-dessus.

Code : Java

int nbre1, nbre2, nbre3;        //déclaration des variables

nbre1 = nbre2 = nbre3 = 0;                  //initialisation

nbre1 = nbre1 + 1;  //nbre1 = lui même donc 0 + 1 => nbre1 = 1

nbre1 = nbre1 + 1;  // nbre1 = 1 (cf ci-dessus) maintenant nbre1 = 1 + 1 = 2!!!

nbre2 = nbre1;         //nbre2 = nbre1 = 2

nbre2 = nbre2 * 2;  //nbre2 = 2 => nbre2 = 2 * 2 = 4

nbre3 = nbre2;         //nbre3 = nbre2 = 4

nbre3 = nbre3 / nbre3;    //nbre3 = 4 / 4 = 1

nbre1 = nbre3;        //nbre1 = nbre3 = 1

nbre1 = nbre1 - 1;// nbre1 = 1 - 1 = 0

Et là aussi, il existe une syntaxe qui raccourcit l'écriture de ce genre d'opération. Regardez bien :

Code : Java

nbre1 = nbre1 + 1;

nbre1 += 1;

nbre1++;

++nbre1;

Ces trois syntaxes correspondent exactement à la même opération. La troisième syntaxe sera certainement celle que vous utiliserez le plus... mais ne marche que pour augmenter la valeur de 1 ! Si vous devez augmenter la valeur d'une variable de 2, utilisez les deux syntaxes précédentes. On appelle cette syntaxe l'incrémentation. La dernière fait la même chose que la troisième, mais avec une subtilité en plus... Nous en reparlerons dans le chapitre sur les boucles.

Sinon, la syntaxe est identique pour la soustraction :

Code : Java

nbre1 = nbre1 - 1;

nbre1 -= 1;

nbre1--;

--nbre1;

Même commentaire que pour l'addition sauf qu'ici, la troisième syntaxe s'appelle la décrémentation.

Les raccourcis pour la multiplication marchent aussi ; regardez plutôt :
Code : Java

nbre1 = nbre1 * 2;

nbre1 *= 2;

nbre1 = nbre1 / 2;

nbre1 /= 2;

TRES IMPORTANT == On ne peut faire de traitement arithmétique que sur des variables de même type, sous peine de perdre de la précision lors du calcul. On ne s'amuse pas à diviser un int par un float ! Ou pire, par un char !! Et ceci est valable pour tous les opérateurs arithmétiques et pour tous les types de variables numériques. Essayer de garder une certaine rigueur pour vos calculs arithmétiques.

Voici les raisons de ma mise en garde.
Comme je vous l'ai dit plus haut, chaque type de variable a une contenance différente et, pour faire simple, nous allons comparer nos variables à différents récipients.
Une variable de type :

byte correspondrait à un dé à coudre. On ne met pas beaucoup de chose dedans...
int, à un verre. C'est déjà plus grand.
double, à un baril. Pfiou, on en met là-dedans...

A partir de là, ce n'est plus que du bon sens. Vous devez facilement voir que vous pouvez mettre le contenu d'un dé à coudre dans un verre ou un baril. Mais par contre, si vous versez le contenu d'un baril dans un verre... Il y en a plein par terre !
Cela s'appelle : une perte de précision !

Ainsi, si nous affectons le résultat d' une opération sur deux variables de type double dans une variable de type int, le résultat sera de type int et donc ne sera pas un réel mais un entier.

Pour afficher le contenu d'une variable dans la console, il vous suffit d'appeler l'instruction : System.out.println(maVariable);, ou encore System.out.print(maDeuxiemeVariable);.

Je suppose que vous voudriez aussi mettre du texte en même temps que vos variables... Eh bien sachez que l'opérateur + sert aussi comme opérateur de concaténation, c'est-à-dire qu'il permet de mixer du texte brut avec des variables.

Voici un exemple d'affichage avec une perte de précision :
Code : Java

double nbre1 = 10, nbre2 = 3;

 int resultat = (int)(nbre1 / nbre2);

 System.out.println("Le résultat est = " + resultat);

Sachez aussi que vous pouvez tout à fait mettre des calculs dans un affichage, comme ceci System.out.print("Résultat = " + nbre1/nbre2); (le plus joue ici le rôle d'opérateur de concaténation) ; ceci vous permet d'économiser une variable et donc de la mémoire.

Mais pour le bien de ce chapitre, nous n'allons pas utiliser cette méthode...
Vous devez voir que le résultat fait 3, au lieu de 3.33333333333333... Et je pense que vous êtes intrigués par ça :
int resultat = (int)(nbre1 / nbre2);

Avant de vous expliquer, remplacez la ligne citée ci-dessus par celle-ci :
int resultat = nbre1 / nbre2;

Vous devez voir qu'Eclipse n'aime pas du tout !
Pour savoir pourquoi, nous allons voir ce qu'on appelle les conversions ou "cast".

Les conversions, ou "cast"

Comme expliqué plus haut, les variables de type double contiennent plus d'informations que les variables de type int.

Ici, il va falloir écouter comme il faut... heu, pardon ! Lire comme il faut !
Nous allons voir un truc super important en Java. Ne vous en déplaise, vous serez amenés à convertir des variables...

Conversion de type int vers un autre type numérique

D'un type int en type float :

Code : Java

1 2	int i = 123; float j = (float)i;

D'un type int en double :

Code : Java

1 2	int i = 123; double j = (double)i;

Et inversement :
Code : Java

double i = 1.23;

double j = 2.9999999;

int k = (int)i; // k vaut 1

k = (int)j; // k vaut 2

Ce type de conversion s'appelle une conversion d'ajustement ou cast de variable.

Vous l'avez vu : nous pouvons passer directement d'un type int à un type double. Mais ceci ne fonctionnera pas dans le sens inverse sans une perte de précision.
En effet comme vous avez pu le constater, lorsque nous castons un double en int, la valeur de ce double est tronqué. Ce qui signifie que l'int en question prendra la valeur entière du double quelle que soit la valeur des décimales.

Pour en revenir à notre ancien problème, il est aussi possible de caster le résultat d'une opération mathématique. En mettant celle-ci entre () et précédée du type de cast souhaité.
Donc :
Code : Java

double nbre1 = 10, nbre2 = 3;

 int resultat = (int)(nbre1 / nbre2);

 System.out.println("Le résultat est = " + resultat);

Fonctionne parfaitement. Mais pour un résultat optimal, vous devez mettre le résultat de l'opération en type double.

Et si on faisait l'inverse ? Si nous déclarons deux entiers et que nous mettons le résultat dans un double ?

Comme ceci ?
Code : Java

int nbre1 = 3, nbre2 = 2;

 double resultat = nbre1 / nbre2;

 System.out.println("Le résultat est = " + resultat);

Vous auriez 1 comme résultat.
Je ne cast pas ici, car un double peut contenir un int.

Et comme ça ?

Code : Java

int nbre1 = 3, nbre2 = 2;

 double resultat = (double)(nbre1 / nbre2);

 System.out.println("Le résultat est = " + resultat);

Idem...

Comment doit-on faire, alors ?

Avant de vous donner la réponse, vous devez savoir qu'en Java, comme dans d'autres langages d'ailleurs, il y a la notion de priorité d'opération et là, nous en avons un très bon exemple !

Sachez que l'affectation, le calcul, le cast, le test, l'incrémentation... toutes ces choses sont des opérations !
Et Java les fait dans un certain ordre, suivant une priorité.

Dans le cas qui nous intéresse, il y a trois opérations :

un calcul,
un cast de valeur de résultat de calcul,
une affectation dans la variable resultat.

Eh bien Java exécute cette ligne dans cet ordre !
Il fait le calcul (ici 3/2), il cast le résultat en double, puis il l'affecte dans notre variable resultat.

D'accord, mais pourquoi on n'a pas 1.5, alors ?

C'est simple : lors de la première opération de Java, la JVM voit un cast à effectuer mais sur un résultat de calcul. La JVM fait ce calcul (division de deux int qui, ici, nous donne 1), puis le cast (toujours 1) et affecte la valeur à la variable (encore et toujours 1).
Donc, pour avoir un résultat correct, il faudrait caster chaque nombre avant de faire l'opération, comme ceci :
Code : Java

int nbre1 = 3, nbre2 = 2;

 double resultat = (double)(nbre1) / (double)(nbre2);

 System.out.println("Le résultat est = " + resultat); //affiche: Le résultat est = 1.5

Message reçu mais... peut-on changer un type numérique en autre chose ?

Bien sûr, je ne détaillerai pas trop ceci mais maintenant, vous allez transformer l'argument d'un type donné, int par exemple, en String.

Voici la méthode à appliquer

Code : Java

int i = 12;

    String j = new String();

     j = j.valueOf(i);

j est donc une variable de type String contenant la chaîne de caractères 12. Ceci fonctionne aussi avec les autres types numériques. Voyons maintenant comment faire marche arrière, en partant de ce que nous venons de faire.

Code : Java

int i = 12;

String j = new String();

        j = j.valueOf(i);

        int k = Integer.valueOf(j).intValue();

Maintenant, la variable k est de type int, et contient le nombre 12.

Il y a l'équivalent de intValue() pour les autres types numérique : floatValue(), doubleValue()...

Astuce d'Eclipse

Retapez le code qu'Eclipse n'aimait pas ; pour mémoire, c'était celui-ci :
Code : Java

double nbre1 = 10, nbre2 = 3;

int resultat = nbre1 / nbre2;

System.out.println("Le résultat est = " + resultat);

Eclipse vous souligne nbre1 / nbre2 et vous met une croix rouge sur la gauche de la zone d'édition, sur cette même ligne.

Si vous cliquez sur cette croix rouge, vous aurez ceci :

Double-cliquez sur "Add cast to 'int'" et Eclipse vous met automatiquement le cast de l'opération !
Ensuite pour tester, vous pouvez cliquez sur "Run" ou appuyer sur Control + F11.
Si vous faites cette manipulation (Ctrl + F11), une fenêtre s'ouvre et vous demande quelle ressource sauver, puis lancer. Pour le moment, le choix est simple puisque vous n'avez qu'une classe. Vous n'avez plus qu'à valider et votre programme se lance !

Au fil de ce tutoriel, vous verrez que cette manipulation va beaucoup vous aider pour des erreurs en tous genres !

// // 0 comments //

java du zéro

Les variables et les opérateurs

Les différents types de variables

Commençons par les variables de type numérique

Nous avons aussi des variables stockant du caractère

Nous avons aussi le type booléen

Et aussi le type String

Les opérateurs arithmétiques

Les opérateurs arithmétiques

Quelques exemples de calcul

Les conversions, ou "cast"

Astuce d'Eclipse

0 comments to "Les variables et les opérateurs"

Post a Comment

About This Blog

Blog Archive