 |
|
3) Contrôle du flux du programme |
|
|
|
|
| Texte original |
|
Traducteur : Jean-Pierre VIDAL |
|
|
|
|
///
|
Ce chapitre contient 6 pages
1
2
3
4
5
6
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//: c03:AllOps.java
// Tests all the operators on all the
// primitive data types to show which
// ones are accepted by the Java compiler.
class AllOps {
// To accept the results of a boolean test:
void f(boolean b) {}
void boolTest(boolean x, boolean y) {
// Arithmetic operators:
//! x = x * y;
//! x = x / y;
//! x = x % y;
//! x = x + y;
//! x = x - y;
//! x++;
//! x--;
//! x = +y;
//! x = -y;
// Relational and logical:
//! f(x > y);
//! f(x >= y);
//! f(x < y);
//! f(x <= y);
f(x == y);
f(x != y);
f(!y);
x = x && y;
x = x || y;
// Bitwise operators:
//! x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Compound assignment:
//! x += y;
//! x -= y;
//! x *= y;
//! x /= y;
//! x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! char c = (char)x;
//! byte B = (byte)x;
//! short s = (short)x;
//! int i = (int)x;
//! long l = (long)x;
//! float f = (float)x;
//! double d = (double)x;
}
void charTest(char x, char y) {
// Arithmetic operators:
x = (char)(x * y);
x = (char)(x / y);
x = (char)(x % y);
x = (char)(x + y);
x = (char)(x - y);
x++;
x--;
x = (char)+y;
x = (char)-y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x= (char)~y;
x = (char)(x & y);
x = (char)(x | y);
x = (char)(x ^ y);
x = (char)(x << 1);
x = (char)(x >> 1);
x = (char)(x >>> 1);
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean b = (boolean)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void byteTest(byte x, byte y) {
// Arithmetic operators:
x = (byte)(x* y);
x = (byte)(x / y);
x = (byte)(x % y);
x = (byte)(x + y);
x = (byte)(x - y);
x++;
x--;
x = (byte)+ y;
x = (byte)- y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = (byte)~y;
x = (byte)(x & y);
x = (byte)(x | y);
x = (byte)(x ^ y);
x = (byte)(x << 1);
x = (byte)(x >> 1);
x = (byte)(x >>> 1);
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean b = (boolean)x;
char c = (char)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void shortTest(short x, short y) {
// Arithmetic operators:
x = (short)(x * y);
x = (short)(x / y);
x = (short)(x % y);
x = (short)(x + y);
x = (short)(x - y);
x++;
x--;
x = (short)+y;
x = (short)-y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = (short)~y;
x = (short)(x & y);
x = (short)(x | y);
x = (short)(x ^ y);
x = (short)(x << 1);
x = (short)(x >> 1);
x = (short)(x >>> 1);
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void intTest(int x, int y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
x = x << 1;
x = x >> 1;
x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void longTest(long x, long y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
x = x << 1;
x = x >> 1;
x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
float f = (float)x;
double d = (double)x;
}
void floatTest(float x, float y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
//! x = ~y;
//! x = x & y;
//! x = x | y;
//! x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
//! x &= y;
//! x ^= y;
//! x |= y;
// Casting:
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
double d = (double)x;
}
void doubleTest(double x, double y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
//! x = ~y;
//! x = x & y;
//! x = x | y;
//! x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
//! x &= y;
//! x ^= y;
//! x |= y;
// Casting:
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
}
} ///:~
|
|
//: c03:AllOps.java
// Test de tous les opérateurs en liaison avec
// tous les types de données primitifs afin de montrer
// les associations acceptées par le compilateur Java.
class AllOps {
// Accepter les résultats d'un test booléen :
void f(boolean b) {}
void boolTest(boolean x, boolean y) {
// Opérateurs arithmétiques :
//! x = x * y;
//! x = x / y;
//! x = x % y;
//! x = x + y;
//! x = x - y;
//! x++;
//! x--;
//! x = +y;
//! x = -y;
// Opérateurs relationnels et logiques :
//! f(x > y);
//! f(x >= y);
//! f(x < y);
//! f(x <= y);
f(x == y);
f(x != y);
f(!y);
x = x && y;
x = x || y;
// Opérateurs bit à bit :
//! x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Affectation composée :
//! x += y;
//! x -= y;
//! x *= y;
//! x /= y;
//! x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Changement de type :
//! char c = (char)x;
//! byte B = (byte)x;
//! short s = (short)x;
//! int i = (int)x;
//! long l = (long)x;
//! float f = (float)x;
//! double d = (double)x;
}
void charTest(char x, char y) {
// Opérateurs arithmétiques :
x = (char)(x * y);
x = (char)(x / y);
x = (char)(x % y);
x = (char)(x + y);
x = (char)(x - y);
x++;
x--;
x = (char)+y;
x = (char)-y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
x= (char)~y;
x = (char)(x & y);
x = (char)(x | y);
x = (char)(x ^ y);
x = (char)(x << 1);
x = (char)(x >> 1);
x = (char)(x >>> 1);
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Changement de type :
//! boolean b = (boolean)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void byteTest(byte x, byte y) {
// Opérateurs arithmétiques :
x = (byte)(x* y);
x = (byte)(x / y);
x = (byte)(x % y);
x = (byte)(x + y);
x = (byte)(x - y);
x++;
x--;
x = (byte)+ y;
x = (byte)- y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
x = (byte)~y;
x = (byte)(x & y);
x = (byte)(x | y);
x = (byte)(x ^ y);
x = (byte)(x << 1);
x = (byte)(x >> 1);
x = (byte)(x >>> 1);
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Changement de type :
//! boolean b = (boolean)x;
char c = (char)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void shortTest(short x, short y) {
// Opérateurs arithmétiques :
x = (short)(x * y);
x = (short)(x / y);
x = (short)(x % y);
x = (short)(x + y);
x = (short)(x - y);
x++;
x--;
x = (short)+y;
x = (short)-y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
x = (short)~y;
x = (short)(x & y);
x = (short)(x | y);
x = (short)(x ^ y);
x = (short)(x << 1);
x = (short)(x >> 1);
x = (short)(x >>> 1);
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Changement de type :
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void intTest(int x, int y) {
// Opérateurs arithmétiques :
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
x = x << 1;
x = x >> 1;
x = x >>> 1;
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Changement de type :
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void longTest(long x, long y) {
// Opérateurs arithmétiques :
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
x = x << 1;
x = x >> 1;
x = x >>> 1;
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Changement de type :
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
float f = (float)x;
double d = (double)x;
}
void floatTest(float x, float y) {
// Opérateurs arithmétiques :
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
//! x = ~y;
//! x = x & y;
//! x = x | y;
//! x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
//! x &= y;
//! x ^= y;
//! x |= y;
// Changement de type :
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
double d = (double)x;
}
void doubleTest(double x, double y) {
// Opérateurs arithmétiques :
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x--;
x = +y;
x = -y;
// Opérateurs relationnels et logiques :
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Opérateurs bit à bit :
//! x = ~y;
//! x = x & y;
//! x = x | y;
//! x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Affectation composée :
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
//! x &= y;
//! x ^= y;
//! x |= y;
// Changement de type :
//! boolean b = (boolean)x;
char c = (char)x;
byte B = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
}
} ///:~
|
|
|
|
|
Note that
boolean is quite limited. You can assign to it the
values true and false, and you can test it for truth or falsehood,
but you cannot add booleans or perform any other type of operation on
them.
|
|
Noter que le type boolean est totalement limité. On peut
lui assigner les valeurs true et false, on peut tester sa vérité
ou sa fausseté, mais on ne peut ni additionner des booléens ni effectuer un autre type d'opération
avec eux.
|
|
|
|
|
In char, byte, and
short you can see the effect of promotion with the
arithmetic operators. Each arithmetic operation on any of those types results in
an int result, which must be explicitly cast back to the original type (a
narrowing conversion that might lose information) to assign back to that type.
With int values, however, you do not need to cast, because everything is
already an int. Don’t be lulled into thinking everything is safe,
though. If you multiply two ints that are big enough, you’ll
overflow the result. The following example demonstrates
this:
|
|
On peut observer l'effet de la promotion des types char,
byte, et short avec l'application d'un opérateur arithmétique sur
l'un d'entre eux. Le résultat est un int, qui doit être explicitement transtypé
vers le type original (c'est à dire une conversion rétrécissante qui peut entraîner une perte
d'information) afin de l'affecter à une variable de ce type. Avec les valeurs int,
toutefois, il n'est pas besoin de transtyper, puisque tout ce qu'on obtient est toujours un
int. N'allez cependant pas croire qu'on peut faire n'importe quoi en toute
impunité. Le résultat de la multiplication de deux ints un peu trop grands peut
entraîner un débordement. L'exemple suivant en fait la démonstration :
|
|
|
|
//: c03:Overflow.java
// Surprise! Java lets you overflow.
public class Overflow {
public static void main(String[] args) {
int big = 0x7fffffff; // max int value
prt("big = " + big);
int bigger = big * 4;
prt("bigger = " + bigger);
}
static void prt(String s) {
System.out.println(s);
}
} ///:~
|
|
//: c03:Overflow.java
// Surprise! Java ne contrôle pas vos débordements.
public class Overflow {
public static void main(String[] args) {
int big = 0x7fffffff; // plus grande valeur int
prt("big = " + big);
int bigger = big * 4;
prt("bigger = " + bigger);
}
static void prt(String s) {
System.out.println(s);
}
} ///:~
|
|
|
|
|
The output of this is:
|
|
Voici le résultat :
|
|
|
|
big = 2147483647
bigger = -4
|
|
big = 2147483647
bigger = -4
|
|
|
|
|
and you get no errors or warnings from
the compiler, and no exceptions at run-time. Java is good, but it’s not
that good.
|
|
La compilation se déroule sans erreur ni avertissement ; il n'y a pas
d'exception lors de l'exécution : Java est puissant, mais tout de même pas à ce
point-là.
|
|
|
|
|
Compound assignments do not
require casts for char, byte, or short, even though they
are performing promotions that have the same results as the direct arithmetic
operations. On the other hand, the lack of the cast certainly simplifies the
code.
|
|
Les affectations composées ne nécessitent pas de transtypage pour
les types char, byte, ou short, bien qu'elles
entraînent des promotions qui ont le même résultat que les opérations arithmétiques directes. Cette
absence de transtypage simplifie certainement le code.
|
|
|
|
|
You can see that, with the exception of
boolean, any primitive type can be cast to any
other primitive type. Again, you must be aware of the effect of a narrowing
conversion when casting to a smaller type, otherwise you
might unknowingly lose information during the
cast.
|
|
On remarque qu'à l'exception du type boolean, tous les
types primitifs peuvent être transtypés entre eux. Il faut rester attentif à l'effet des
conversions rétrécissantes en transtypant vers un type plus petit, sous peine de perdre de
l'information sans en être averti.
|
|
|
|
Execution control
|
|
Le Contrôle d'exécution
|
|
|
|
|
Java uses all of C’s execution
control statements, so if you’ve programmed with C or C++ then most of
what you see will be familiar. Most procedural programming languages have some
kind of control statements, and there is often overlap among languages. In Java,
the keywords include if-else, while, do-while, for,
and a selection statement called switch. Java does not, however, support
the much-maligned goto (which can still be the most expedient way to
solve certain types of problems). You can still do a goto-like jump, but it is
much more constrained than a typical
goto.
|
|
Java utilisant toutes les instructions de contrôle de C, bien des choses
seront familières au programmeur C ou C++. La plupart des langages de programmation procéduraux
possèdent le même type d'instructions de contrôle, et on retrouve beaucoup de choses d'un langage à
un autre. En Java, les mots clefs sont if-else, while,
do-while, for, et une instruction de sélection appelée
switch. Toutefois Java ne possède pas le goto très pernicieux
(lequel reste le moyen le plus expéditif pour traiter certains types de problèmes). Il est possible
d'effectuer un saut ressemblant au goto, mais bien plus contraignant qu'un
goto classique.
|
|
|
|
true and false
|
|
true et false
|
|
|
|
|
All conditional statements use the truth
or falsehood of a conditional expression to determine the execution path. An
example of a conditional expression is A == B. This uses the conditional
operator == to see if the value of A is equivalent to the value of
B. The expression returns true or false. Any of the
relational operators you’ve seen earlier in this chapter can be used to
produce a conditional statement. Note that Java doesn’t allow you to use a
number as a boolean, even though it’s allowed in C and C++ (where
truth is nonzero and falsehood is zero). If you want to use a non-boolean
in a boolean test, such as if(a), you must first convert it to a
boolean value using a conditional expression, such as if(a !=
0).
|
|
Toutes les instructions conditionnelles utilisent la vérité ou la fausseté
d'une expression conditionnelle pour déterminer le chemin d'exécution. Exemple d'une expression
conditionnelle : A == B. Elle utilise l'opérateur conditionnel
== pour déterminer si la valeur A est équivalente à la valeur
B. L'expression renvoie la valeur true ou false.
Tous les opérateurs relationnels vus plus haut dans ce chapitre peuvent être utilisés pour créer
une instruction conditionnelle. Il faut garder à l'esprit que Java ne permet pas d'utiliser un
nombre à la place d'un boolean, même si c'est autorisé en C et C++ (pour lesquels
la vérité est « différent de zéro » et la fausseté « zéro »). Pour utiliser un
non-boolean dans un test boolean, tel que if(a),
il faut d'abord le convertir en une valeur boolean en utilisant une expression
booléenne, par exemple if(a != 0).
|
|
|
|
if-else
|
|
if-else
|
|
|
|
|
The if-else statement is probably
the most basic way to control program flow. The else is optional, so you
can use if in two forms:
|
|
L'instruction if-else est sans doute le moyen le plus
simple de contrôler le déroulement du programme. La clause else est optionnelle,
et par suite l'instruction if possède deux formes :
|
|
|
|
if(Boolean-expression)
statement
|
|
if(expression booléenne)
instruction
|
|
|
|
|
or
|
|
ou bien :
|
|
|
|
if(Boolean-expression)
statement
else
statement
|
|
if(expression booléenne)
instruction
else
instruction
|
|
|
|
|
The conditional must produce a
boolean result. The statement means either a simple statement
terminated by a semicolon or a compound statement, which is a group of simple
statements enclosed in braces. Any time the word “statement”
is used, it always implies that the statement can be simple or compound.
|
|
L'expression conditionnelle expression booléenne doit fournir un
résultat de type boolean. instruction désigne soit une instruction simple
terminée par un point-virgule, soit une instruction composée, c'est à dire un groupe d'instructions
simples placées entre deux accolades. Par la suite, chaque utilisation du mot
« instruction » sous-entendra que l'instruction peut être simple ou
composée.
|
|
|
|
|
As an example of if-else, here is
a test( ) method that will tell you whether a guess is above, below,
or equivalent to a target number:
|
|
Voici un exemple d'instruction if-else : la méthode
test( ) détermine si une estimation est supérieure, inférieure ou équivalente
à une valeur donnée :
|
|
|
|
//: c03:IfElse.java
public class IfElse {
static int test(int testval, int target) {
int result = 0;
if(testval > target)
result = +1;
else if(testval < target)
result = -1;
else
result = 0; // Match
return result;
}
public static void main(String[] args) {
System.out.println(test(10, 5));
System.out.println(test(5, 10));
System.out.println(test(5, 5));
}
} ///:~
|
|
//: c03:IfElse.java
public class IfElse {
static int test(int testval, int target) {
int result = 0;
if(testval > target)
result = +1;
else if(testval < target)
result = -1;
else
result = 0; // Identique
return result;
}
public static void main(String[] args) {
System.out.println(test(10, 5));
System.out.println(test(5, 10));
System.out.println(test(5, 5));
}
} ///:~
|
|
|
|
It is conventional to indent the body of a control flow statement so the reader might easily determine where it begins and ends.
|
|
Par convention, on indente le corps d'une instruction de contrôle de flux, afin que le lecteur
détermine plus facilement son début et sa fin.
|
|
|
|
return
|
|
return
|
|
|
|
The return keyword has two
purposes: it specifies what value a method will return (if it doesn’t have
a void return value) and it causes that value to be returned immediately.
The test( ) method above can be rewritten to take advantage of
this:
|
|
Le mot clef return a deux buts : il spécifie la
valeur que la méthode doit retourner (si elle n'a pas un type de retour void) et
provoque le renvoi immédiat de cette valeur. Voici la méthode test( )
ci-dessus, réécrite en utilisant cette propriété :
|
|
|
|
//: c03:IfElse2.java
public class IfElse2 {
static int test(int testval, int target) {
int result = 0;
if(testval > target)
return +1;
else if(testval < target)
return -1;
else
return 0; // Match
}
public static void main(String[] args) {
System.out.println(test(10, 5));
System.out.println(test(5, 10));
System.out.println(test(5, 5));
}
} ///:~
|
|
//: c03:IfElse2.java
public class IfElse2 {
static int test(int testval, int target) {
int result = 0;
if(testval > target)
return +1;
else if(testval < target)
return -1;
else
return 0; // Identique
}
public static void main(String[] args) {
System.out.println(test(10, 5));
System.out.println(test(5, 10));
System.out.println(test(5, 5));
}
} ///:~
|
|
|
|
|
|
|
|
|
|
|
|
|
