Aller au menu - Aller au contenu

Icône Les variables et les opérateurs

Par Avatar cysboy
Mise à jour : 12/02/2010
Difficulté : Facile Facile Creative Commons BY-NC-SA
96 702 visites depuis 7 jours, dont 2 896 sur ce chapitre classé 4/786
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. :waw:

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... :p )
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Les différents types de variables

Tout d'abord, je vous conseille vivement de lire le chapitre qu'a écrit M@teo21 sur les variables dans son tutoriel sur le C. Je pense que vous y verrez plus clair.

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*109 à 2*109 (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*1018 à 9*1018 (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
1
2
3
4
5
6
7
8
9
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. :D

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 ! :colere2: Châtiment corporel. ^^
Voici quelques exemples de noms de classes et de variables :
Code : Java
1
2
3
4
5
6
7
8
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 a 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 : :magicien:
Code : Java
1
2
3
4
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 ! :p
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
Retour en haut

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 !! :diable:

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é :p ).
% 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
1
2
3
4
5
6
7
8
9
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
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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
1
2
3
4
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
1
2
3
4
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
1
2
3
4
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 ! :p
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
1
2
3
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".
Retour en haut

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
1
2
3
4
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
1
2
3
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
1
2
3
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
1
2
3
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 ! :D

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
1
2
3
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. :waw:

Voici la méthode à appliquer

Code : Java
1
2
3
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
1
2
3
4
5
6
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()...
Retour en haut

Astuce d'Eclipse

Retapez le code qu'Eclipse n'aimait pas ; pour mémoire, c'était celui-ci :
Code : Java
1
2
3
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.

Image utilisateur


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

Image utilisateur


Double-cliquez sur "Add cast to 'int'" et Eclipse vous met automatiquement le cast de l'opération ! :waw:
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 ! :p

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

Retour en haut

Q.C.M.

Lequel de ces types d'arguments de classes n'existe pas ?
Qu'est-ce qu'une variable ?
Quelle est la principale différence entre un type de variable long et un type de variable double ?
Qu'est-ce qui ne va pas avec cette opération ?
Code : Java
1
2
3
4
5
double i = 10;
double j = 20;
double k = 30;
int m = 0;
m = (double)(i*j/k);
Qu'est-ce qui ne va pas ici ?
Code : Java
1
2
3
4
int i = 10;
int j = 12
int k = 0;
k = (i*i)*(j*j)/j+i;

Statistiques de réponses au QCM

Retour en haut
Je suis bien conscient que ces deux chapitres étaient riches en vocabulaire, en nouveautés (pour ceux qui n'auraient pas lu les cours de M@teo), mais bon, voilà : votre calvaire... ne fait que commencer. :diable:
Eh oui : tout ceci était un amuse-bouche ! Maintenant, nous rentrons dans le vif du sujet. Dans tous les cas, si vous n' avez pas eu 20/20 à ces deux questionnaires, relisez ces deux chapitres !!

Allez on s' y jette : Lire les entrées clavier !
TAAAAÏÏÏÏAAAAUUUUTTTT ! :zorro:
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
62 commentaires pour "Les variables et les opérateurs"
Note moyenne : 3.57 / 4 (1025 votes)
Pseudo Commentaire
Hors ligne Velcya # Posté le 05/04/2012 à 21:38:27

Avis : Bon

Petite faute d'orthographe à la fin, aux QCM, à l'avant-dernière question : "Qu'est-ce qui ne va pas avec cette opération ?"

La toute petite faute : "Je crois bien que la variable m devrait être un int sinon on PERT (perd) de la précision."
Hors ligne b2 # Posté le 24/04/2012 à 22:52:55
On quête d'apprentissage...

 Citation
Code : Java
1
2
3
double nbre1 = 10, nbre2 = 3;
 int resultat = (int)(nbre1 / nbre2);
 System.out.println("Le résultat est = " + resultat);


ça marche aussi ;) (et avec sans perte de précision)

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
double nbre1 = 3, nbre2 = 2;
		if (nbre1 % 2 == 0 && nbre2 % 2 == 0) {
			int resultat = (int) (nbre1/nbre2);
		System.out.println("Le résultat est = " + resultat);
		
		}
		else {
		 double resultat = (double)(nbre1 / nbre2);
		 System.out.println("Le résultat est = " + resultat);
		
	}
XHTML / CSS : 100%
PHP / MySQL : 80%
VB .NET : 50%
Photoshop : 60%
Blender : 72%
Maya : 15%
Java : 5%
 
Hors ligne jizozor # Posté le 02/05/2012 à 12:41:27
" focus and simplicity "
Avatar

 Bonjour a tous ,
Quelqu'un pourrait il m'expliquer en clair cette partie ? :(
Code : Java
1
2
3
4
nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;

Code : Java
1
2
3
4
nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;

J'ai pas bien compris ce que c'est ligne veulent dire meme en faisant des correspondances avec l'exemple plus haut .
Aussi a ce niveau
Code : Java
1
2
3
4
5
6
7
8
9
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

A quoi cela sert d'initialiser les variables nbr1,2,et 3 au depart si ensuite elles ne seront pas utiliser
" nbr1 = nbr2 = nbr3 = 0 " pour ensuite nbr1 = 1+3 ? quel est le but dans cet autre ?
Merci tres bon tutoriel a ce niveau,a part ces deux questions tout est impeccable .
Bill Gates : " So don't whine about our mistakes. Learm from them. "
Mark Zuckrberg : " Move fast and break things. "
Steves Jobs : " focus and simplicity "
:)
 
Hors ligne L0Lth # Posté le 15/05/2012 à 22:26:56

Citation : jizozor
Bonjour a tous ,
Quelqu'un pourrait il m'expliquer en clair cette partie ? :(
Code : Java
1
2
3
4
5
6
7
nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;
// Chacune de ces opérations revient à ôter 1 à la variable nbre1.
// Ceci pour démontrer que l'on peut utiliser différente façon d'écrire cette opération.
// Dont certaines (--nbre1) ont une particularité*/

Code : Java
1
2
3
4
nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;

J'ai pas bien compris ce que c'est ligne veulent dire meme en faisant des correspondances avec l'exemple plus haut .
Aussi a ce niveau
Code : Java
1
2
3
4
5
6
7
8
9
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

A quoi cela sert d'initialiser les variables nbr1,2,et 3 au depart si ensuite elles ne seront pas utiliser
" nbr1 = nbr2 = nbr3 = 0 " pour ensuite nbr1 = 1+3 ? quel est le but dans cet autre ?
Code : Autre
1
2
3

// Même sens qu'avant. On joue avec les possibilités d'opération.
// Faut pas voir plus loin.
// Opération d'affectation, d'addition, division, modulo etc...

Merci tres bon tutoriel a ce niveau,a part ces deux questions tout est impeccable .
Connecté holofruit # Posté hier à 11:38:19

Citation
Qu'est-ce qui ne va pas avec cette opération ?
Code : Java - Sélectionner
double i = 10;
double j = 20;
double k = 30;
int m = 0;
m = (double)(i*j/k);


Réponses possibles :
Citation
1 Je crois bien que la variable m devrait être un double, sinon on perd de la précision.
2 Je vois pas ! Franchement....
3 Les variables doivent avoir au moins deux lettres !
4 Je crois bien que la variable m devrait être un int sinon on perd de la précision.


La bonne réponse est la 1 mais je ne suis pas vraiment d'accord sur le sens de la réponse. Car si "m" n'est pas un double on a une erreur et non pas une perte de précision.
Dans l'exemple il faudrait que m soit un double et le cast un int ainsi la réponse deviendrait :

1 Je crois bien que le "cast" devrait être un double, sinon on perd de la précision.

Je ne sais pas si j'ai mal compris le sens de la question mais si quelqu'un peut me donner son avis, merci.

Et merci pour ce tuto Java :)

Voir tous les commentaires