Utilisateur:Fasten/Java tutorial/Variables et types

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Variables et types
Icône de la faculté
Chapitre no 2
Leçon : Java tutorial
Chap. préc. :Introduction
Chap. suiv. :Opérations
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Java tutorial : Variables et types
Fasten/Java tutorial/Variables et types
 », n'a pu être restituée correctement ci-dessus.

Sur les autres projets Wikimedia :

La base de tout programme est la manipulation de données et d'ailleurs tous les programmes ne sont que ça ! C’est pourquoi il faut savoir quels sont les types de données de base que l’on peut utiliser dans le langage Java mais aussi comment créer des données que l’on appelle variable.

Les types de base[modifier | modifier le wikicode]

Les types de donnée de base en Java sont :

  • boolean : un booléen (d'ordre 2 en réalité) qui ne pourra prendre que les valeurs true ou false.
  • byte : un entier relatif très court (entre -128 et 127).
  • short : un entier relatif court (entre -32 768 et 32 767).
  • int : un entier relatif (entre -2 147 483 648 et 2 147 483 647).
  • long : un entier relatif long (entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807).
  • float : un nombre décimal (entre et ).
  • double : un nombre décimal à double précision (entre et ).
  • char : un caractère (entre '\u0000' et '\uffff').
  • string : une chaine de caractère.
Type primitif Taille en octets Valeur par défaut Représentation Information complémentaire
boolean Non spécifié false true / false La taille dépends de la JVM
char 2 '\u0000' Entre '\u0000' et '\uffff' Caractère unicode
byte 1 0
short 2 0
int 4 0
long 8 0L
float 4 0f Entre et Précision
double 8 0d Entre et Précision


Des conversions existent entre ces différents types de données. En effet, il est possible de convertir un float en double, ou encore un int en double. Il est aussi possible de convertir un caractère en entier et inversement. Le meilleur moyen de connaître les conversions possibles est encore de les essayer. Il est cependant inutile d'essayer de convertir un booléen en quoi que ce soit d'autre.

Remarque : dans la pratique, pour représenter des nombres, on utilise le plus souvent que les types int et double. Cela évite en général les problèmes de conversion. Remarque : les chaînes de caractères (String) ne sont pas un type de base en Java, mais sont bel et bien des objets. Le traitement de ce type d'objet en mémoire n’est pas le même que les autres objets.

Déclarer une variable[modifier | modifier le wikicode]

La déclaration d'une variable se fait toujours de la même manière quel que soit le type de donnée utilisé (y compris les types qui ne sont pas de base mais cela sera vu dans le chapitre consacré aux objets).

Prenons donc un exemple de déclaration de variable :

public static int monEntier ;
//Je crée ici un entier sans l'initialiser, sa valeur est la valeur par défaut pour le type int: 0.
monEntier = 4 ;
//J’ai maintenant changé la valeur 4 à mon entier.

public static boolean monBooleen = true ;
//Il est aussi possible de donner une valeur à la variable dès sa déclaration.

On peut remarquer ici l'apparition des mots clés public et static, il n’est pas nécessaire de s'en préoccuper, leur signification sera vu dans le chapitre consacré aux objets. Ces termes ne sont d'ailleurs pas obligatoires mais on se contentera de les laisser tant que l’on ne connaît pas exactement leur signification.

Si l’on souhaite donner une valeur particulière à une variable de type char, il faut écrire le caractère entre ' '. Pour les chaînes de caractères, ou String, il faut écrire la chaîne entre " ".

Déclarer une constante[modifier | modifier le wikicode]

Il arrive parfois que l’on ait besoin d’utiliser des constantes, notamment pour donner un nom explicite à un chiffre, qui sera donc plus simple à manipuler pour notre esprit. La déclaration de constante se fait donc de la manière suivante :

public static final String MA_CONSTANTE = "Peuh" ;

Le mot final indique qu'une fois une valeur donnée, cette variable ne pourra plus en changer.

Remarque : Il est important de garder cette convention de nommage des constantes !

Conversion de type[modifier | modifier le wikicode]

En Java, il est possible de modifier le type des variables. Il existe deux manières de réaliser cette opération :

  • une conversion implicite : la modification est réalisée automatiquement par le compilateur, si la conversion du type A vers le type B peut se faire sans perte quelle que soit la valeur du type A ;
  • une conversion explicite via l'opérateur cast sous la forme (type_souhaité)variable est nécessaire. Par exemple
{
  int x = (int)Math.PI;
}

Variables et classes[modifier | modifier le wikicode]

Les types de variables ne sont pas des classes, il est aisé de les confondre mais les conventions habituelles d'écritures permettent de les distinguer. Les types de variables sont toujours écrits en minuscules, par contre les classes ont en principe leur premier caractère en majuscule. Aussi lorsque vous rencontrez un Int, ce n’est pas un type de base mais bien une classe en effet les variables peuvent être encapsulées, et Java fournit pour tous[1] les types de variables des classes d'encapsulage appelées wrappers (paquetages).

Ceci peu être utile dans certains cas pour bénéficier de certaines caractéristiques de la classe mère Object. Par exemple, la pose d'un verrou de synchronisation (instruction synchronized) ne peut se faire que sur un objet.

Références[modifier | modifier le wikicode]

  1. anglais http://docs.oracle.com/javase/6/docs/api/java/sql/Wrapper.html

Document au format H T M L[html]le document est sous une licence copyright[licence Copyright] • anglais • lien vers le document • Information sur les types primitifs


The basis of any program is the manipulation of data and also all the programs are just that! Therefore we must know what types of data that can be used in the Java language but also how to create data which is called variable.

The basic types[modifier | modifier le wikicode]

The basic data types in Java are:

  • Boolean is a boolean (of order 2 in reality) that can take the valuestrue orfalse.
  • Byte is a very short integer (-128 to 127)
  • Short is a short integer (-32768 to 32767)
  • Int represents an integer between -2 147 483 648 and 2 147 483 647)
  • Long is a long integer (between -9 223 372 036 854 775 808 and 9 223 372 036 854 775 807)
  • Float is a decimal number (between and )
  • Double is a decimal number to double precision. (Between and )
  • Char is a character (from '\ u0000' and '\ uFFFF').


Primitive Size in bytes Default Representation More information
boolean Not specified false true / false The size depends on the JVM
tank 2 '\ u0000' Between '\ u0000' and '\ uFFFF' Unicode character
byte 1 0
shorts 2 0
int 4 0
long 8 0L
float 4 0f Between and Accuracy
double 8 0d Between and Accuracy


Conversions between these different types of data. Indeed, it is possible to convert afloatindoubleor anintindouble. It is also possible to convert a wide character and vice versa. The best way to know the prospective convert is still to try. However, it is useless to try to convert a boolean to anything else.

Note: in practice, to represent numbers are used most often as the typeintanddouble. This prevents general conversion problems. Note: strings (String) are not a basic type in Java, but are actually objects. The treatment of this type of object in memory is not the same as the other objects.

Declaring a variable[modifier | modifier le wikicode]

The declaration of a variable is always the same way regardless of the type of data used (including types that are not basic but it will be seen in the chapter on objects).

So let's take an example of variable declaration:

public static int monEntier;
/ / Here I create a world without initializing it, its value is the default value for type int: 0.
monEntier = 4;
/ / Now I have changed the value 4 in my world.

public static boolean monBooleen = true;
/ / It is also possible to give a value to the variable declaration.

We can note here the appearance of key wordspublicandstatic, there is no need to worry about, their meaning will be seen in the chapter on objects. These terms are also not required but we will just leave them as we do not know exactly what they mean.

If one wishes to give special value to a variable of typechar, write the character between '.' For strings, orString, write the string "".

Declaring a constant[modifier | modifier le wikicode]

Sometimes you may need to use constants, especially to give a meaningful name to a figure, which will be easier to manipulate our minds. The constant declaration is therefore as follows:

public static final String MA_CONSTANTE = "Pooh";

The wordFinal indicates that once a given value, this variable will not be able to change it.

Note: It is important to keep this naming convention of constants!

Conversion type[modifier | modifier le wikicode]

In Java, it is possible to change the type of variables. There are two ways to do this:

  • An implicit conversion':the change is made automatically by the compiler, if the conversion of type A to type B can be done without loss regardless of the value of the type A;
  • Anexplicitconversion via the operatorCast as(type_souhaité) variableis necessary. For example
{
  int x = (int) Math.PI;
}

Variables and classes[modifier | modifier le wikicode]

The types of variables are not Class s, it is easy to confuse them but the usual conventions of writing can be distinguished. The types of variables are always written in lower case, for against the classes are in principle their first character capitalized. So when you encounter aInt is not a basic type but a class because the variables can be encapsulated, and Java provides for all types of variables called class encapsulation wrappers.

This just in some cases be useful to take advantage of certain features of the superclass Object. For example, the installation of a synchronization lock (synchronized instruction) can be done on an object.

byte
20=
1
21=
2
22=
4
23=
8
24=
16
25=
32
26=
64
+ ou -
short
20=
1
21=
2
22=
4
23=
8
24=
16
25=
32
26=
64
27=
128
28=
256
29=
512
210=
1024
211=
2048
212=
4096
213=
8192
214=
16384
+ ou -
  • Byte: un byte a 8 bits (entre -128 et 127)
  • Short: un short a 16 bits (entre -32768 et 32767)
  • Int: un integer a 32 bits (entre -2 147 483 648 et 2 147 483 647)
  • Long: un long a 64 bits (entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807)
class Recette // la classe "Recette"
{ // parenthèse ouvrant pour la classe
     boolean halal = true;                     // la variable "halal" est vrai
     int numeroPersonnes = 2;                  // c’est une recette pour deux personnes
  
     public static void main (String [] args)  // la méthode "main"
     {                                         // parenthèse ouvrant pour la méthode
        "..."                                  // instruction de travail
     }                                         // parenthèse fermante correspondante pour la méthode
} // parenthèse fermante correspondante pour la classe

Exercices:

  • Écrivez une classe avec cinq variables avec types primitif différente.
  • Écrivez une classe avec une méthode "main".
  • Écrivez une classe avec une instruction "System.out.println".