| précédent | suivant | table des matières | s'évaluer |
|
|
1 Types primitifs
Ce sont des types de donnée non objet qu'on retrouve dans de nombreux autres langages de programmation. A chacun de ces types correspond un type objet appelé «type enveloppe».
1.1 Booléen : boolean
C’est l’ensemble des deux valeurs true et false
1.2 Caractère : char (visualisation, BabelMap)
Ensemble des valeurs unicode ( valeurs de ’\u0000’ à ’\uffff’ avec 4 chiffres obligatoires après ’\u’) Les 128 premiers caractères sont les codes ASCII et se notent entre apostrophes : ’a’, ’1’, ’\’’, ’\n’.
Compléments d’information sur Unicode, et aussi ici.
Un caractère est représenté sur 2 octets.
1.3 Types entiers
Les différents types entiers se distinguent par la taille de leur représentation.
|
Le codage des entiers se fait en binaire pour les entiers positifs et en binaire en complément à deux pour les entiers négatifs :
|
Le codage des nombres négatifs en complément à deux s'obtient de la façon suivante :
|
Les littéraux peuvent être notée dans trois bases différentes :
Les littéraux sont par défaut de type int. Un littéral peut être rendu de type long en le suffixant avec l ou L.
1.4 Types flottants
Ils se distinguent par la taille de leur représentation, et par conséquent par la précision et l’étendue des valeurs.
La représentation des réels est une représentation en virgule flottante : signe, exposant et significande ( IEEE754 ).
La valeur du nombre en représentation flottante est obtenue de la façon suivante :
| float : ( 4 octets ) dans ce cas max vaut 255 : ensemble des nombres [-3.40282347E38 .. -1.40239846E-45], 0, [1.40239846E-45 .. 3.40282347E38] | |
| double : ( 8 octets ) dans ce cas max vaut 2047 : ensemble des nombres [-1.79769313486231570E308 .. -4.94065645841246544E-324], 0, [4.94065645841246544E-324 .. 1.79769313486231570E308] | |
Les littéraux sont représentés de la façon suivante :
entier.{entier}{E{+, -}entier} ou .entier{E{+, -}entier}
Ce qui est entre accolades est facultatif. Par défaut un littéral flottant est de type double. Un littéral peut être forcée dans le type float en la suffixant avec f ou F ou dans le type double en la suffixant avec d ou D.
A la suite d’opérations en virgule flottante, on peut obtenir POSITIVE_INFINITY ou NEGATIVE_INFINITY, ou NaN ( Not a Number).
Les opérations sur les nombre flottants n’ont pas les même propriétés que les opérations habituellement utilisées sur les nombres réels ( commutativité, associativité, égalité ...) Voir :
Pour se rendre compte de certains des problèmes évoqués dans les articles précédents, essayer les programmes suivants :
avec des valeur initiales pour a et b qui sont des puissances de 4 + 0.1, pour d’autres valeurs, ou en changeant les double en float ...
float A=3.1F,B=2.3F,C=1.5F; float X,Y; X=(A*B)*C; Y=A*(B*C); System.out.println(X); System.out.println(Y); System.out.println(); System.out.println(4096.1F-4095.1F); System.out.println(4096.1-4095.1); |
les sorties console sont les suivantes :10.695 10.694999 1.0 1.0000000000004547 |
|
A essayer avec des valeur initiales pour a et b qui sont des puissances de 4 + 0.1, pour d’autres valeurs, ou en changeant les double en float ...
public void xxx(){
double a = 64.1;
double b = 63.1;
// pour d’autres valeurs de a et b
// la suite des x est (1, 1, 1, ...
double x = 1.0;
for (int i=1; i <= 14; i++){
System.out.println(""+i+" "+x);
x = a*x - b;// b = a-1 donc x = b*(x-1)+x
// x initial = 1, donc x = x = 1
}
} |
1 1.0 2 0.9999999999999929 3 0.9999999999995381 4 0.9999999999703917 5 0.9999999981021048 6 0.9999998783449158 7 0.9999922019090874 8 0.9995001423725043 9 0.967959126077524 10 -1.05382001843072 11 -130.64986318140916 12 -8437.756229928327 13 -540923.2743384057 14 -3.4673244985091805E7 |
1.5 Conversions
Les conversions vers un type dont la taille de la représentation est plus grande ou égale se font automatiquement sans avoir besoin d’être spécifié.
| Dans l'image ci-contre, les flèches pleines indiquent les conversions automatiques sans perte d'information, les flèches en pointillés, les conversions automatiques avec une possible perte d'information : |
|
Les autres conversions peuvent entraîner une perte d’information, et doivent être spécifiées par un opérateur de cast.
Exemples :
double d = 12345.6;
byte b = (byte)d; // b vaut 57
2 Variables, constantes
Une variable doit être déclarée. Une déclaration est un type suivi du nom de la variable. Le nom peut être suivi d’une initialisation ( = valeur).
Une déclaration de constante se fait comme une déclarationde variable précédée du mot final.
Un nom de variable ou de constante est contitué de lettres, de chiffres de '_', et de symboles monétaires ('$', '£', '€', etc... ) et ne peut pas commencer par un chiffre. Plus généralement la méthode Character.isJavaIdentifierStart(Char c) retourne true si c peut commencer un identificateur, et la méthode Character.isJavaIdentifierPart(Char c) retourne true si c peut faire partie du reste de l'identificateur.
L'identificateur ne peut pas être un mot réservé Java :
abstract |
continue |
for |
new |
switch |
assert |
default |
goto |
package |
synchronized |
boolean |
do |
if |
private |
this |
break |
double |
implements |
protected |
throw |
byte |
else |
import |
public |
throws |
case |
enum |
instanceof |
return |
transient |
catch |
extends |
int |
short |
try |
char |
final |
interface |
static |
void |
class |
finally |
long |
strictfp |
volatile |
const |
float |
native |
super |
while |
| On représente les variables ou constantes de type primitifs de la façon suivante : | int i = 12; double d = 3.14; |
 |
Par convention les noms de variable, attributs, paramètres commencent par une minuscule, les nom de classe, d'interface et d'énumération commencent par une majuscule. Quand un identificateur est composé de plusieurs mots, tous les mots sauf le premier commencent par une majuscule.
3 Expressions (visualisation)
Les expressions sont construites à partir de littéraux, variables, constantes, opérateurs et parenthèses. Toute les expressions retourne une valeur. Les expressions ( sauf pour les opérateurs && et || ) sont évaluées en évaluant d’abord l’opérande de gauche, puis l’opérande de droite, puis en réalisant l’opération.
int i = 0 ;
t[++i]=++i ; // affectation de 2 à t[1]
Certaines instructions sont des instructions expressions et peuvent se trouver partout où on peut trouver une instruction :
| sélection dans un tableau, sélection d'un attribut ou méthode de classe, et paramètre d'un appel de méthode | |||
| Pré ou post incrémentation ou décrémentation | |||
| négation booléenne | |||
| Négation bit à bit | |||
| Transtypage. | |||
| Multiplication | |||
| Division : division réelle si un des deux opérandes est un réel, et quotient de la division si les deux opérandes sont des entiers. Une division par 0 lève une exception. | |||
| Reste de la division. (opérandes entiers ou réels) | |||
| addition et soustraction. | |||
Décalage à gauche signé, complété par des 0, décalage à droite signé,
le remplissage dépend du signe.
|
|||
Décalage à droite,
le remplissage se fait avec de 0.
|
|||
| Opérateurs de comparaison. | |||
| Opérateurs de comparaison. | |||
| Et bit à bit pour les opérandes entiers. Et évaluant les 2 opérandes pour des opérandes booléens. |
|||
| Ou exclusif bit à bit pour des opérandes entiers. Ou évaluant les 2 opérandes pour des opérandes booléens. |
|||
| Ou inclusif bit à bit pour des opérandes entiers. Ou inclusif évaluant les 2 opérandes pour des opérandes booléens. |
|||
| Et logique. le premier opérande est évalué : s’il vaut false la valeur de l’expression est false, sinon c’est la valeur du second opérande. | |||
| Ou logique. le premier opérande est évalué : s’il vaut true la valeur de l’expression est true, sinon c’est la valeur du second opérande. | |||
Opérateur ternaire a ? b : c
|
|||
*= /= %= <<= >>= >>>= &= |= ^= |
Opérateurs d’affectation : la partie gauche doit être une variable. Les opérateurs composés ont le sens suivant : a op= b est équivalent à a = (T)(a op ( b )) où T est le type de a. L’expression b est évaluée avant de d’évaluer a op b ; String s; s += ’a’+’b’; est équivalent à s = s+(’a’+’b’). |
||
| a pour valeur true si l’opérande de gauche a pour type l’opérande de droite et false sinon. | |||
Les opérations sur les nombres réels ne lèvent pas d’exceptions, mais produisent des valeurs NaN, POSITIVE_INFINITY ou NEGATIVE_INFINITY
float a = 1000f; System.out.println(a/0); // affichage de Infinity a = a*a*a*a; System.out.println(a); // affichage de 1.0E12 a = a*a*a*a; System.out.println(a); // affichage de Infinity System.out.println(a/a); // affichage de NaN