Médiaforma

All posts tagged types

Dans cette section, nous allons passer en revue les classes permettant de définir et de manipuler des types composites. Après l’avoir parcourue, vous ferez la différence entre les types simples et les types composites, et saurez passer de l’un à l’autre sans aucune difficulté.

La classe Boolean

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

Les objets Boolean peuvent prendre deux valeurs : FALSE et TRUE :

public final static Boolean FALSE
public final static Boolean TRUE

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    Boolean B1 = new Boolean(false);
    System.out.println("B1 = " + B1);

    B1 = Boolean.TRUE;
    System.out.println("B1 = " + B1);
  }
}

Le premier bloc d’instructions définit un objet Boolean, lui affecte la valeur false, et l’affiche :

Boolean B1 = new Boolean(false);
System.out.println("B1 = " + B1);

Le second bloc d’instructions assigne la valeur TRUE à cet objet et l’affiche :

B1 = Boolean.TRUE;
System.out.println("B1 = " + B1);

Le constructeur

Le constructeur Boolean permet de définir un objet Boolean à partir d’une variable ou d’une valeur boolean :

public Boolean(boolean value)

Exemple :

Boolean B1 = new Boolean(false);
Boolean B2 = new Boolean(true);

Les méthodes

booleanValue()

La méthode booleanValue() retourne la valeur booléenne d’un objet Boolean :

public boolean booleanValue()

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    Boolean B1 = new Boolean(false);
    System.out.println("B1 = " + B1.booleanValue());
  }
}

La première instruction définit l’objet Boolean B1 et lui affecte la valeur false :

Boolean B1 = new Boolean(false);

La seconde instruction utilise la méthode booleanValue() pour afficher la valeur de l’objet B1 :

System.out.println("B1 = " + B1.booleanValue());

Notez que l’instruction suivante aurait eu le même effet :

System.out.println("B1 = " + B1);

equals()

La méthode equals() teste l’égalité entre deux objets Boolean. Elle renvoie la valeur true si les deux objets sont égaux et la valeur false dans le cas contraire :

public boolean equals(Object obj)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    Boolean B1 = new Boolean(false);
    Boolean B2 = new Boolean(true);
    Boolean B3 = new Boolean(false);

    System.out.println("B1 = " + B1);
    System.out.println("B2 = " + B2);
    System.out.println("B3 = " + B3);

    if (B1.equals(B2))
      System.out.println("B1 = B2");
    else
      System.out.println("B1 <> B2");
    if (B1.equals(B3))
      System.out.println("B1 = B3");
    else
      System.out.println("B1 <> B3");
  }
}

Le premier bloc d’instructions définit trois objets Boolean, B1, B2 et B3 :

Boolean B1 = new Boolean(false);
Boolean B2 = new Boolean(true);
Boolean B3 = new Boolean(false);

Le deuxième bloc d’instructions affiche la valeur de ces trois objets :

System.out.println("B1 = " + B1);
System.out.println("B2 = " + B2);
System.out.println("B3 = " + B3);

Le troisième bloc d’instructions utilise la méthode equals() pour tester l’égalité des objets B1, B2 et B3 :

if (B1.equals(B2))
  System.out.println("B1 = B2");
else
  System.out.println("B1 <> B2");
if (B1.equals(B3))
  System.out.println("B1 = B3");
else
  System.out.println("B1 <> B3");

getBoolean()

La méthode getBoolean() renvoie la valeur d’une propriété boolean dont le nom est précisé dans l’argument :

public static boolean getBoolean(String name)

toString()

La méthode toString() convertit un objet Character en un objet String.

public String toString();

Exemple :

Boolean B = new Boolean(false);
String S = B.toString();

La première instruction définit l’objet Boolean B et lui affecte la valeur false :

Boolean B = new Boolean(false);

La seconde instruction définit l’objet String S et lui affecte la valeur convertie en String de B :

String S = B.toString();

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';