Médiaforma

All posts tagged double

Les constantes, variables et méthodes de cette classe sont immédiatement accessibles sans qu’il soit nécessaire d’utiliser une instruction import. La déclaration suivante est implicite :

import java.lang.*;

Les variables

MAX_VALUE représente la valeur maximale qui puisse être stockée dans une variable double : 1.79769313486231570e+308d.

MIN_VALUE représente la valeur minimale qui puisse être stockée dans une variable double : 4.94065645841246544e-324d.

NEGATIVE_INFINITY représente la valeur -infini.

POSITIVE_INFINITY représente la valeur +infini.

NaN représente une valeur indéterminée.

Le constructeur

Le constructeur Double permet de définir un objet Double à partir d’une variable double :

public Double(double value);

Exemple :

Voir méthodes IntValue, longValue, floatValue et hashCode.

Les méthodes

isInfinite()

Cette méthode retourne la valeur true si le double spécifié en argument a une valeur infinie. Elle retourne la valeur false dans le cas contraire :

public static boolean isInfinite(double v)

Exemple :

public class Test {
  public static void main (String args[]) {
    double x = 1/0.0;
    System.out.println(x);
    System.out.println(Double.isInfinite(x));
  }
}

Le premier println affiche la valeur infinity et le second la valeur true. Java considère donc que la valeur stockée dans la variable x est infinie.

Remarque

Vous pouvez également utiliser la méthode isInfinite() pour déterminer si un objet Double a une valeur infinie :

public boolean isInfinite();

toString()

Cette méthode renvoie une chaîne de caractères qui représente le double passé en argument :

public static native String toString(double d);
Exemple :
public class Test {
  public static void main (String args[])
  {
    double x = Math.PI;
    String S;
    S = Double.toString(x);
    System.out.println(S.length());
  }
}

Après conversion du double x en chaîne de caractères :

S = Double.toString(x);

il devient possible d’utiliser les méthodes de la classe String pour travailler sur la valeur convertie du double :

System.out.println(S.length());

intValue()

La méthode intValue() retourne la valeur entière de l’objet Double sur lequel elle est appliquée :

public int intValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    double x = Math.PI;
    Double drr = new Double(x);
    System.out.println(drr.intValue());
  }
}

La première instruction affecte la constante PI à la variable double x :

double x = Math.PI;

La deuxième instruction définit l’objet Double drr à partir de la variable double x :

Double drr = new Double(x);

Enfin, la troisième instruction affiche la valeur entière de l’objet drr :

System.out.println(drr.intValue());

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

double x = Math.PI;
System.out.println((int) x);

longValue()

La méthode longValue() retourne la valeur entière long de l’objet Double sur lequel elle est appliquée :

public long longValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    double x = 1486618620.65617;
    Double Dx = new Double(x);
    long Lx = Dx.longValue();
    System.out.println(Lx);
  }
}

La première instruction initialise la variable x :

double x = 1486618620.65617;

La deuxième instruction définit l’objet Double Dx à partir de la variable double x :

Double drr = new Double(x);

La troisième instruction définit la variable long Lx en appliquant la méthode longValue() sur l’objet Double Dx :

long Lx = Dx.longValue();

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

double x = 1486618620.65617;
long Lx = (long) x;

floatValue()

La méthode floatValue() retourne la valeur réelle float de l’objet Double sur lequel elle est appliquée :

public float floatValue()

Exemple :

public class Test {
  public static void main (String args[]) {
    double x = 1.234567890123456789e12d;
    Double Dx = new Double(x);
    float Fx = Dx.floatValue();
    System.out.println(Fx);
  }
}

La première instruction initialise la variable x :

double x = 1.234567890123456789e12d;

La deuxième instruction définit l’objet Double Dx à partir de la variable double x :

Double drr = new Double(x);

La troisième instruction définit la variable float Fx en appliquant la méthode floatValue() sur l’objet Double Dx :

float Fx = Dx.floatValue();

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

double x = 1.234567890123456789e12d;
float Fx = (float) x;

doubleValue()

La méthode doubleValue() retourne la valeur réelle double de l’objet Double sur lequel elle est appliquée :

public double doubleValue()

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    double r1;
    char ch;
    String Interm;

    System.out.println("Entrez une valeur réelle double : ");
    Interm = Lit();
    r1=Double.valueOf(Interm).doubleValue();
  }

public static String Lit() throws java.io.IOException {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r') {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

La fonction Lit() acquiert les caractères tapés au clavier et les retourne sous forme d’une chaîne String lorsque la touche Entrée est pressée.

Dans la procédure main(), un message invite l’utilisateur à entrer une valeur réelle double :

System.out.println("Entrez une valeur réelle double : ");

Les caractères tapés sont ensuite mémorisés et stockés dans la variable String Interm :

Interm = Lit();

L’instruction suivante stocke dans la variable r1 la conversion réelle double de la chaîne Interm :

r1=Double.valueOf(Interm).doubleValue();

Cette instruction peut paraître complexe, voire inextricable ! Regardons-la de plus près. La méthode valueOf(Interm) convertit la chaîne Interm en un objet Double. Cette méthode fait partie de la classe Double. Elle est donc référencée par Double.valueOf(Interm). On applique ensuite la méthode doubleValue() à l’objet Double qui vient d’être défini pour le convertir en un réel double…

hashCode()

Cette méthode retourne le hashcode (chaque objet Java possède un hashcode qui lui est propre) de l’objet sur lequel elle est appliquée :

public int hashCode();

Exemple :

public class Test {
  public static void main (String args[]) {
    double x = 1.234567890123456789e12d;
    Double Dx = new Double(x);
    System.out.println(Dx.hashCode());
  }
}

La troisième instruction de la procédure main affiche le hashcode de l’objet Double précédemment défini :

Double Dx = new Double(x);
System.out.println(Dx.hashCode());

equals()

Cette méthode compare deux objets. Elle renvoie la valeur true si les objets sont identiques et la valeur false dans le cas contraire :

public boolean equals(Object obj)

valueOf()

Cette méthode retourne un objet Double initialisé à la valeur numérique placée dans l’argument String :

public static native Double valueOf(String s) throws NumberFormatException;

Exemple :

Voir la méthode doubleValue().

doubleToLongBits()

Cette méthode renvoie la représentation binaire d’une valeur double :

public static native long doubleToLongBits(double value);
Exemple :
public class Test {
  public static void main (String args[]) {
    double x = 123.456d;
    long binaire = Double.doubleToLongBits(x);
    System.out.println("Valeur initiale : " + x);
    System.out.println("Conversion binaire : " + binaire);
    System.out.println("Conversion binaire->double : " + Double.longBitsToDouble(binaire));
  }
}

Dans un premier temps, une valeur réelle double est stockée dans une variable double :

double x = 123.456d;

Cette variable est convertie en binaire avec la méthode doubleToLongBits() et stockée dans la variable long binaire :

long binaire = Double.doubleToLongBits(x);

La valeur initiale et la conversion binaire sont ensuite affichées :

System.out.println("Valeur initiale : " + x);
System.out.println("Conversion binaire : " + binaire);

Enfin, la valeur binaire est reconvertie en un réel double avec la méthode longBitsToDouble() et affichée :

System.out.println("Conversion binaire->double : " + Double.longBitsToDouble(binaire));

Voici le résultat :

 

 
longBitsToDouble()

Cette méthode renvoie la représentation double d’une valeur binaire :

public static double longBitsToDouble(long bits);

Exemple :

Voir la méthode doubleToLongBits().

parseDouble()

Cette méthode renvoie la représentation String d’un objet Double.


Types de données prédéfinis

Les types de données prédéfinis en Java ne sont pas très nombreux. Ils permettent de manipuler des nombres entiers (byte, short, int, long), des nombres réels (float, double), des booléens (boolean) et des caractères (char). Par extension, vous pouvez également utiliser la classe String pour manipuler facilement des chaînes de caractères.

Les divers types de données utilisables en Java vont être passés en revue dans les sections suivantes.

Nombres entiers

Selon la taille des nombres à manipuler, vous utiliserez le format byte, short, int ou long :

  • Les entiers byte sont codés sur 8 bits. Ils permettent de manipuler des nombres compris entre -2^7 et (2^7)- 1, c’est-à-dire entre -128 et 127.
  • Les entiers short sont codés sur 16 bits. Ils permettent de manipuler des nombres compris entre -2^15 et (2^15)-1, c’est-à-dire entre -32768 et 32767.
  • Les entiers int sont codés sur 32 bits. Ils permettent de manipuler des nombres compris entre -2^31 et (2^31)-1, c’est-à-dire entre -2147483648 et 2147483647.
  • Enfin, les entiers long sont codés sur 64 bits. Ils permettent de manipuler des nombres compris entre -2^63 et 2^63, c’est-à-dire entre -9223372036854775808 et 9223372036854775807.

Exemples :

Les nombres entiers peuvent être exprimés en décimal (base 10), en hexadécimal (base 16) ou en octal (base 8) :

byte NombreDécimal = 127;       // Un nombre entier exprimé en décimal
int NombreHexadécimal = 0x5ec;  // Un nombre entier exprimé en hexadécimal
long NombreOctal = 0346;        // Un nombre entier exprimé en octal

Nombres réels

Les nombres réels sont composés d’une partie entière suivie d’un point, d’une partie décimale, de la lettre e (ou E) et d’un exposant, éventuellement précédé d’un signe + ou -.

Voici quelques exemples de nombres réels :

325.707
3.25707E2
.325707E3
-45.567E-5

Le langage Java manipule deux types de réels :

  • Les réels float sont codés en simple précision sur 32 bits (1.40239846e-45 à 3.40282347e38).
  • Les réels double sont codés en double précision sur 64 bits (4.94065645841246544e-324 à 1.79769313486231570e308).

Vous pouvez spécifier le type d’une variable réelle pendant sa création en utilisant les mots clés double et float :

double d = 34.56567;
float f = 123.56;

Attention :

La seconde instruction est incorrecte : Lorsque Java rencontre un point décimal dans une affectation, il suppose qu’il s’agit d’un réel double. En affectant un nombre contenant un point décimal à une variable float, vous obtiendrez un message d’erreur vous indiquant une incompatibilité de type. Pour résoudre ce problème, vous utiliserez l’une des deux syntaxes suivantes :

float f = (float)123.56;
float f = 123.56f;
La lettre "f" à la fin de la seconde instruction indique que la donnée est de type float et non double. De la même façon, vous pouvez utiliser le suffixe "d" pour affecter une valeur double à une variable :
double d = 145.56565d;

Remarque

Les suffixes f et d peuvent être indifféremment utilisés en lettres minuscules ou majuscules.

Booléens

Ils peuvent prendre la valeur true ou la valeur false. Si vous le souhaitez, il est également possible d’utiliser (comme dans de nombreux autres langages) un nombre non nul pour représenter la valeur true et le nombre 0 pour représenter la valeur false.

Dans l’exemple suivant, les instructions définies entre les deux accolades seront exécutées. En effet, la variable Valeur étant non nulle, sa valeur est interprétée comme true.

Valeur = 4;
if Valeur then {
  ...
}

Type char

Une variable de type char peut contenir un (et un seul !) caractère. Java utilise le jeu de caractères 16 bits Unicode qui contient quelque 65 000 caractères! Il est donc possible de manipuler des caractères spécifiques à la langue française (à, é, è, ç, etc.) dans les variables char… et par extension dans les chaînes String.

A titre d’exemple, les deux affectations ci-après sont correctes :

char c1 = 'é';
char c2 = '1';

Par contre, cette troisième affectation produira une erreur lorsqu’elle sera exécutée :

char c3 = 'er';


Comme tous les langages, Java est composé d’un certain nombre de mots-clés. Nous allons les passer en revue dans cette section.

Commentaires

Pour faciliter la compréhension et la maintenance du code, il est souvent utile d’ajouter des commentaires dans le source d’une application ou d’une applet.

Le langage Java supporte trois types de commentaires :

Commentaires – Premier type

Les caractères “//” définissent un commentaire sur une (et une seule) ligne qui s’étend jusqu’au retour chariot de fin de ligne.

Les deux exemples ci-après sont corrects :

// Ce commentaire occupe une ligne
for (i=1; i<10; i++) // Le traitement est répété 10 fois

Par contre, l’exemple ci-après est incorrect. Les caractères “//” ne peuvent pas être placés à l’intérieur d’une instruction :

for (i=1; // Le traitement est répété 10 fois i<10; i++)

Commentaires – Deuxième type

Les signes “/*” et “*/” peuvent être utilisés pour placer des commentaires sur plusieurs lignes ; par exemple :

/* Ceci est un commentaire
   qui occupe deux lignes */

Contrairement au premier type de commentaire (//), il est ici possible de placer un commentaire à l’intérieur d’une instruction :

for (i=1; /* Le traitement est répété 10 fois */ i<10; i++)

Commentaires – Troisième type

Ce type de commentaire est destiné au programme javadoc.exe, livré avec le SDK. Il permet de documenter automatiquement une application.

Sans entrer dans les détails, sachez que les lignes de code qui commencent par les caractères “/**” contiennent des commentaires qui seront automatiquement insérés dans un document HTML lors de l’exécution du programme Javadoc.

Exemple :

/** Ces commentaires
  sont destinés au
  système JAVADOC
  qui génère de la documentation
  API à partir du code */

Identificateurs

Le terme “identificateurs” désigne les constantes, les variables et les objets utilisés dans le langage. Ces derniers commencent obligatoirement par une lettre (A à Z, a à z, ou une autre lettre appartenant au jeu de caractères Unicode dont la valeur hexadécimale est supérieure à H00C0), un caractère de soulignement (_) ou un dollar ($). Les caractères suivants peuvent être des lettres, des caractères de soulignement, des dollars ou des chiffres.

Par exemple, les noms suivants peuvent être utilisés pour référencer un identificateur :

Var12_5
Bien_que_très_long_ce_nom_est_acceptable
$Celui-ci_aussi

Par contre, ces deux identifiants ne sont pas autorisés :

Nombre d'itérations
4Var

Le premier, parce qu’il contient un espace. Le second, parce qu’il commence par un chiffre.

Remarque
Unicode est un standard qui permet des échanges de texte dans différentes langues.

Mots réservés du langage

Le tableau ci-après liste les mots clés du langage. Ces derniers ne peuvent pas être utilisés comme noms de variable, d’objet, de classe, etc. Leur utilisation sera décrite dans la suite de l’ouvrage.

Mot clé Signification
abstract Définit une classe ou une fonction qui n’a pas été totalement implémentée.
boolean Déclaration d’une variable booléenne.
break Fin prématurée d’une boucle.
byte Déclaration d’une variable byte.
case Teste si une variable a une valeur particulière dans un bloc switch.
catch Traitement suite à une exception.
char Déclaration d’une variable char.
class Déclaration d’une classe.
const Ce mot est réservé mais pas utilisé dans le langage.
continue Interdit l’exécution d’une boucle lorsqu’une condition logique est satisfaite.
default Permet d’exécuter un bloc d’instructions lorsque aucune des constantes case ne concorde avec l’expression placée après le mot switch.
do Boucle do while.
double Déclaration d’une variable double.
else Dans une instruction if else, permet d’exécuter un bloc d’instructions si la condition if n’est pas satisfaite.
extends Permet de sous-classer une classe parent.
false Valeur booléenne false.
final Indique à Java que la classe courante ne peut être sous-classée.
finally Permet d’exécuter systématiquement une portion de code à chaque occurrence d’une exception.
float Déclaration d’une variable float.
for Exécute répétitivement un bloc d’instructions.
goto Ce mot est réservé mais pas utilisé dans le langage.
if Teste une condition logique.
implements Détermine l’interface à utiliser.
import Fait référence à un package Java externe.
instanceof Détermine le type d’un objet.
int Déclaration d’une variable int.
interface Indique à Java que le code qui suit doit être utilisé pour définir une nouvelle interface.
long Déclaration d’une variable long.
native Permet d’appeler un programme externe.
new Permet de définir une nouvelle instance de classe.
null Correspond à une valeur non existante.
package Indique à Java le nom du package auquel se réfère le code qui suit.
private Définit une classe, une méthode ou une variable private.
protected Définit une classe, une méthode ou une variable protected.
public Définit une classe, une méthode ou une variable public.
return Définit la valeur retournée par une classe ou une méthode.
short Déclaration d’une variable short.
static Définit une classe, une méthode ou une variable static.
super Fait référence à la classe parent de la classe courante.
switch Permet d’effectuer un test multiple sur une variable.
synchronized Indique à Java qu’une seule instance de cette méthode peut être exécutée à la fois.
this Fait référence à l’objet courant.
throw Indique à Java qu’une exception particulière (autre que Errors et Runtime) doit être traitée dans le prochain bloc catch.
throws Détermine les exceptions gérées par le programmeur dans une déclaration de méthode.
true Valeur booléenne true.
try Définit un bloc de code dans lequel une ou plusieurs exceptions peuvent se produire. Un bloc try doit être suivi d’un bloc catch qui traite les exceptions correspondantes.
void Déclare une procédure Java qui ne renvoie aucune valeur.
volatile Les variables de type volatile peuvent changer de valeur indépendamment du programme Java (date et heure système par exemple)
while Exécute répétitivement un bloc d’instructions.