--------------------------------------------------------------------------
! JAVTYPE.txt: Liste des types prédéfinis en Java - (c) ~/2A
env.
!! A COMPLETER ... Dernière MAJ: 21.08.2006 16h59 / H. Nguyen-Phu
--------------------------------------------------------------------------
Tout objet en Java a un TYPE qui caractérise un ensemble de valeurs et
un ensemble d'opérations
applicables.
TYPES
-----
|----- énumérés (et numériques)
| |------------- discrets
| | |
------------------ booléens [boolean]
| | |
------------------ entiers [byte, short, int, long]
| | |
------------------ caractères [char]
| |
| |------------- réels
| | | ------------------
flottants [float, double]
| |------------- tableaux de types précédents
|
Ex.: char [] label= new char[20];
|
|----- classes (ensemble structuré de données hétérogènes ou
non) [class]
|----- Chaînes de caractères (Unicode) de taille fixe [String]
|----- Chaînes de caractères (Unicode) de taille variable [StringBuffer]
|----- Chaînes de caractères (Unicode) de taille variable [StringBuilder]
CONSEIL :
EVITER DES CONVERSIONS
IMPLICITES en Java: Il faut convertir EXPLICITEMENT dans la mesure du possible
!
-----------------------------------------
=============
------------------------------------------------------------------------------
TYPES
Nature
Taille
Plage de validité /CA: Classe Associée
Java
[CA.MIN_VALUE, ..., CA.MAX_VALUE]
------------------------------------------------------------------------------
boolean BOOLEEN
1
octet 'false'
ou 'true'
char
CAR 2 octets
Unicode:
\u0000 ... \uffff
byte
OCTET 1
octet
[-128, ...,-1, 0, 1, ..., +127]
byte
Plage: [Byte.MIN_VALUE
..., Byte.MAX_VALUE]
short ENTIER
COURT 2 octets
[-32768, .... , +32767]
short
Plage: [Short.MIN_VALUE ..., Short.MAX_VALUE]
int
ENTIER 4 octets
[-2 147 483
648, ..., +2 147 483 647]
int
Plage: [Integer.MIN_VALUE ..., Integer.MAX_VALUE]
long ENTIER
LONG 8 octets
[-9 223 372 036 854 775 808, ...
long
+9
223 372 036 854 775 807]
long
Plage: [Long.MIN_VALUE, ..., Long.MAX_VALUE]
float
REEL 4
octets de (+ ou
-) 1,40239846E-45 ... 3,40282347E+38
float
Plage: [ Float.MIN_VALUE
..., Float.MAX_VALUE]
float
/ précision relative= 1,19E-07
double REEL
DOUBLE 8
octets de (+
ou -) 4,9406545841246544E-324 ...
double
1,7976931348623157E+308
double
Plage: [Double.MIN_VALUE ..., Double.MAX_VALUE]
double
/ précision relative = 2.22045 E-16
///////////////////////////////////////////////////////////////////////////////
Java
|
L.A.O.
-------------------------------------------------------------------------------
TYPE TABLEAUX (Declarations)
<type><nom_tab>=new<type>[<taille>];
| <nom_tab> : TABLEAU [<binf>..<bsup>]
|
DE <TypeC>;
TYPE CHAINES DE CARACTERES (Declarations)
String <nom_chaine>;
| <nom_chaine> : CHAINE
StringBuffer <nom_chaine> = new StringBuffer(); | <nom_chaine> : CHAINE
StringBuilder <nom_chaine>
= new StringBuilder(); | <nom_chaine>
: CHAINE
TYPE CHAINES DE CARACTERES (Exemples typiques d’emploi)
String : chaine1.java
StringBuffer : chaine2.java
StringBuilder : chaine3.java
TYPE Enuméré (DECLARATIONS)
enum <nom_énuméré> { // A partir de Java 5.0
| <nom_énuméré>: ENUM (
|
<nom_membre1>;
| <nom_membre1>,
<nom_membre2>;
| <nom_membre2>,
...
| ...
<nom_membreN>;
| <nom_membreN>
}
| )
TYPE Enuméré (Un exemple d'utilisation: v_enum.java )
TYPE Produit_CARTésien (DECLARATIONS)
class <nom_p_cart>
{
| <nom_p_cart>: P_CART (
|
<type>
<nom_membre1>;
|
<nom_membre1> : <type>;
<type> <nom_membre2>;
|
<nom_membre2> : <type>;
...
| ...
<type>
<nom_membreN>;
|
<nom_membreN> : <type>
}
| )
TYPE Produit_CARTésien (Un exemple d'utilisation)
|
public class etudiant {
| Etudiant: P_CART(
StringBuffer last_n, first_n;
| Nom, Prenom : CHAINE_CAR;
String
nss;
| NSS :
CHAINE_CAR[15];
// char nss [] = new char
[15] ;
| // NSS : No de
Sécurité Sociale
int
age;
| Age : ENTIER;
int [] tests = new
int[7];
| Tests : TABLEAU[1..7] de ENTIER;
float
moyenne;
| Moyenne : REEL
}
| )
cf. fichiers « etudiant.java »,
« p_cart.java », « p_cart_.java » et aussi « verif_.java »
///////////////////////////////////////////////////////////////////////////////
LES CLASSES ASSOCIEES (ou classes enveloppantes ) AUX TYPES PREDEFINIS
EN JAVA
TYPE
CLASSE
boolean Boolean
byte Byte
double Double
float Float
int
Integer
long Long
char
Character
char[fixe] String
char[var.] StringBuffer
char[var.]
StringBuilder // Java 5
Remarque: Toutes les
classes enveloppantes (ou classes d'emballage) sont immuables, i.e.
elles contiennent des types primitifs non modifiables ('final'). Si on
doit modifier leur valeur, il faut créer d'autres classes de stockage (cf.
exemples: entier.java, chaine.java
).
///////////////////////////////////////////////////////////////////////////////
LISTE DE QUELQUES
CONSTANTES USUELLES (ou EQUIVALENTS) EN JAVA
Byte.MIN_VALUE
-128
Byte.MAX_VALUE
+127
Short.MIN_VALUE
-32768
Short.MAX_VALUE
+32767
Integer.MIN_VALUE -2 147 483
648
Integer.MAX_VALUE +2 147
483 647
Long.MIN_VALUE
-9 223 372 036 854 775 808
Long.MAX_VALUE
+9 223 372 036 854 775 807
Float.NEGATIVE_INFINITY = -1.0f / 0.0f
Float.MIN_VALUE
= 1.4E-45f
Float.MAX_VALUE
= 3.4028235E+38f
Float.NaN
= 0.0f / 0.0f
Float.POSITIVE_INFINITY = 1.0f / 0.0f
Précision relative simple: Eps_simple = Math.pow(2,-23); (# 1.192093e-07)
Double.NEGATIVE_INFINITY = -1.0 / 0.0
Double.MIN_VALUE =
4.9E-324
Double.MAX_VALUE =
1.7976931348623157E+308
Double.NaN
= 0.0d / 0.0
Double.POSITIVE_INFINITY= 1.0 / 0.0
Précision relative double: Eps_double = Math.pow(2,-52); (#
2.22044605e-16)
Math.exp(1d)
2.7182818284590455
Math.E
2.7182818284590452354 [Java 5.0]
Définition dans
'java.lang.Math':
public static final double E = 2.7182818284590452354;
e [calculatrice de MS]
2.7182818284590452353602874713527
Math.PI
3.14159265358979323846 [Java 5.0]
4d*Math.atan(1d)
3.141592653589793
Définition dans
'java.lang.Math':
public static final double PI = 3.14159265358979323846;
pi[calculatrice de MS] 3.1415926535897932384626433832795
Thread.MAX_PRIORITY Constante
de priorité maximale (= 10) d'un processus léger.
Thread.MIN_PRIORITY Constante de priorité minimale
(= 1) d'un processus léger.
Thread.NORM_PRIORITY Constante de priorité normale
(= 5) d'un processus léger.
///////////////////////////////////////////////////////////////////////////////