Leçons de niveau 14

Java/Annexe/Nombres

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Nombres
Image logo représentative de la faculté
Annexe 2
Leçon : Java

Annexe de niveau 14.

Précédent :Documenter un programme
Suivant :Glossaire
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Annexe : Nombres
Java/Annexe/Nombres
 », n'a pu être restituée correctement ci-dessus.




Dans cette page, nous traiterons de BigInteger et BigDecimal qui nécessitent Java 5 ou une version postérieur.

Java possède plusieurs types de nombres. Nous pouvons les classer selon plusieurs critères :

  • types primitifs ou types objets ;
  • nombres entiers ou nombres à virgules flottantes.

Les types primitifs[modifier | modifier le wikicode]

Pour les entiers : byte, short, int, long qui occupent respectivement 8, 16, 32 et 64 bits.

Contrairement aux langages de programmation C ou C++, vous ne pouvez pas choisir entre une version « signée » ou pas. Tous les types permettent d'exprimer des nombres positifs et négatifs. Comme Java utilise le prinicipe du complément à 2, le zéro est considéré comme positif.

Ainsi, le type byte permet d'exprimer 2^8=256 nombres (car un byte est codé sur 8 bits). Le nombre 0 est considéré comme positif, donc un byte est compris entre -128 (=2^7) et 127 (=2^7 -1).

Les nombres short sont compris entre -2^15 et 2^15 -1.

Le même raisonnement est valide pour int et long.

Deux types de nombres à virgules flottantes sont disponibles float (32 bits) et double (64 bits). Ils utilisent le standard IEEE 754.

Division entre deux nombres entiers[modifier | modifier le wikicode]

Attention, lorsque vous réalisez une division entre deux nombres entiers, vous obtenez toujours un nombre entier (éventuellement dont la partie décimale a été tronquée).

Division par 0[modifier | modifier le wikicode]

Diviser un entier par 0 entraîne une erreur. Diviser un nombre à virgule flottante est plus particulier.

Upcasting et dowcasting[modifier | modifier le wikicode]

import personnes.Personne;  

2import personnes.Enseignant;  

public class UpDownExample {  

public static void main(final String[] args) {  

Personne p;  

6        Enseignant e = new Enseignant("Durand","Emilie",  

"2780633...",3,"Cloud␣Computing");  

p = e;      // UpCast  

System.out.println("Apres␣p␣=␣e;␣p␣est␣une␣Personne␣"  

10                + (p instanceof Personne)  

+ ";␣p␣est␣un␣Enseignant␣"  

+ (p instanceof Enseignant));  

e = (Enseignant) p; // Downcast  

14        System.out.println("Apres␣e␣=␣p;␣e␣est␣une␣Personne␣"  

+ (e instanceof Personne)  

+ ";␣e␣est␣un␣Enseignant␣"  

+ (e instanceof Enseignant));  

18    }  

}

Dans cet exemple, la variable p de type référence de classe parente peut recevoir la référence d’un objet de classe dérivée, contenue dans e. Inversement, une fois qu’une référence de classe parente contient une référence vers un objet de la classe dérivée, il est possible de mettre cette valeur dans une variable pouvant contenir une référence de la classe parente. Il faut cependant informer le compilateur de cette possible perte de sens en castant la référence.

Les types objets[modifier | modifier le wikicode]

Les types objets ont le désavantage de demander plus de ressources, un plus grand effort de programmation, mais offrent l'avantage d’utiliser des nombres d'une grandeur ou précision supérieures. Seules les ressources de la machine (la mémoire physique) limitent la grandeur et la précsion.

Vous ne pouvez pas utilisez les opérateurs classiques (+,-,*,/) pour BigInteger et BigDecimal. Vous devez recourir à leur version objet.