Java Standard
Edition
Les bases du langage
PARTIE II
- Les bases du langage
Les variables, constantes, énumérations,
les tableaux et les structures de contrôles
Les Variables
■ Les variables servent à mémoriser pendant l’exécution du
programme différentes valeurs utiles pour son fonctionnement.
■ Une variable doit obligatoirement être déclarée avant son
utilisation dans le code.
■ Les caractéristiques d’une variable sont fixés lors de sa
déclaration.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ On distinguera plusieurs catégories de variables selon l’emplacement
de leur déclaration :
– La variable d’instance
■ Elle est déclarée à l’intérieur d’une classe
■ Elle n’existe que si une instance de la classe est disponible.
Chaque instance de classe aura son propre exemplaire de la
variable.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
– La variable de classe
■ Elle est déclarée à l’intérieur d’une classe
■ Elle est accessible directement par le nom de la classe et n’existe
qu’en un seul exemplaire.
– La variable locale
■ Elle est déclarée à l’intérieur d’une fonction
■ Elle n’existe que pendant l’exécution de la fonction et n’est
accessible que par le code de celle-ci.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Nom des variables
– Les variables doivent respecter certaines règles :
■ Le nom d’une variable commence obligatoirement par une lettre.
■ Il peut être constitué de lettres, de chiffres ou du caractère
souligné (_).
■ Il y a une distinction entre minuscules et majuscules (la variable
TOTO est différente de la variable toto)
■ Les mots clés du langage ne doivent pas être utilisés comme nom
de variable.
■ Par convention les noms de variable respectent le camel case
– Ils sont écrits en lettres minuscules sauf la première lettre de chaque
mot si le nom de la variable en comporte plusieurs (Exemple :
nomDeLaVariable)
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Type des variables
– Spécifier un type pour une variable indique quelles
informations pourront y être stockées.
– Deux catégories de types de variables sont disponibles :
■ Les types valeur : la variable contient les informations réelles.
■ Les types référence : la variable contient l’adresse mémoire où se
trouvent les informations.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Type des variables
– Le langage Java dispose de sept types de base qui peuvent être classés
en trois catégories.
– Les types numériques entiers
Types entiers signés
Nom Valeur MIN Valeur MAX Taille occupée en mémoire
byte -128 127 8 bits
short -32768 32767 16 bits
int -2147483648 2147483647 32 bits
long -9223372036854775808 9223372036854775807 64 bits
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Type des variables
– Les types numériques entiers
■ Le choix du type de la variable doit être motivé par les valeurs minimale et
maximale quiu seront stockées dans la variable afin d’optimiser la
mémoire utilisée par la variable.
■ Il est inutile d’utiliser un type long pour une variable dont la valeur
n’excédera pas 90 par exemple, un type byte est dans ce cas largement
suffisant.
■ L’économie de mémoire semble dérisoire pour une variable unique mais
devient appréciable lors de l’utilisation de tableaux de grande dimension.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Type des variables
– Les types numériques décimaux
Nom Valeur MIN Valeur MAX Taille occupée en mémoire
float 1.4E-45 3.4028235E38 4 octes
double 4.9E-324 1.7976931348623157E3 8 octets
08
– Les types numériques caractère
■ Le type char est utilisé pour stocker un caractère unique. Une variable de
type char utilise deux octets pour stocker le code Unicode du caractère.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Type des variables
– Le type booléan
■ Le type boolean permet d’avoir une variable qui peut prendre deux états
vrai/faux, oui/non, on/off et ...
– L’affectation se fait directement avec les valeurs true ou false
comme dans l’exemple suivant :
boolean quantifiable, transformable;
quantifiable = true;
transformable = false;
– Il est impossible d’affecter une autre valeur à une variable de type
boolean.
Ghislain AKINOCHO - [Link]@[Link]
Les Variables
■ Type des variables
– Valeurs par défaut
■ L’initialisation des variables n’est pas toujours obligatoire.
■ C’est le cas pour les variables d’instance qui sont initialisées avec les
valeurs par défaut suivantes.
Type Valeur par défaut Type Valeur par défaut
byte 0 char \u0000
short 0 String null
int 0
float 0.0
double 0.0
boolean false
Les Variables
■ Type des variables
– Valeurs par défaut
■ Par contre les variables locales doivent être initialisées avant leur
première utilisation.
■ Le compilateur effectue une vérification lorsqu’il rencontre l’utilisation
d’une variable locale et déclenche une erreur si la variable n’a pas été
initialisée.
■ Déclaration des variables
type nomVariable ;
Ghislain AKINOCHO - [Link]@[Link]
Les Constantes
■ Dans une application, il arrive fréquemment que l’on utilise des valeurs
numériques ou chaînes de caractères qui ne seront pas modifiées pendant
le fonctionnement de l’application.
■ Dans ce cas, il est conseillé, pour faciliter la lecture du code, de définir ces
valeurs sous forme de constantes.
■ La définition d’une constante se fait en ajoutant le mot clé final devant la
déclaration d’une variable.
■ Son initialisation est obligatoire au moment de sa déclaration (c’est d’ailleurs
le seul endroit où il est possible de faire une affectation à la constante).
Ghislain AKINOCHO - [Link]@[Link]
Les Constantes
■ Une fois déclarée et initialisée, la constante peut être alors utilisée
dans le code à la place de la valeur littérale qu’elle représente.
■ Nomenclature des constantes
✓ Ecrites en majuscule
✓ Les mots suivants sont séparés par le soulignement ( _ )
✓ Exemple : public final int MA_CONSTANTE_JAVA = 10;
final float TAUX_DE_REMISE = 0.2;
float montant = 100 * TAUX_DE_REMISE;
final type NOM_CONSTANTE = valeurInit ;
seulement pour les constantes obligatoire pour les constantes
Ghislain AKINOCHO - [Link]@[Link]
Les Enumérations
■ Une énumération va nous permettre de définir un ensemble de
constantes qui sont liées entre elles. La déclaration se fait de la
manière suivante :
enum Jours La première valeur de l’énumération est
{ initialisée à zéro.
LUNDI, Les constantes suivantes sont ensuite
MARDI, initialisées avec un incrément de un.
MERCREDI,
JEUDI,
VENDREDI,
SAMEDI,
DIMANCHE
}
Ghislain AKINOCHO - [Link]@[Link]
Les Enumérations
■ Une variable de type énumération peut facilement être utilisée dans une
structure switch ... case, il n’est dans ce cas pas nécessaire de faire
précéder les membres de l’énumération du nom de l’énumération.
void testJour (Jours jour) {
switch (jour) {
case LUNDI:
[Link]("Premier jour de la semaine."); break;
case MARDI:
case MERCREDI:
case JEUDI:
[Link]("C'est pour quand le week-end ?"); break;
case VENDREDI:
[Link]("Ouf! Bentot le week end !"); break;
case SAMEDI:
[Link]("Enfin le week end!"); break;
case DIMANCHE:
[Link]("Et ca recommence !"); break;
}
}
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Les tableaux permettent :
– de stocker un ensemble de variables de même type par le même nom et
d’utiliser un indice pour les différencier.
■ Caractéristiques des tableaux :
– Un tableau peut avoir une ou plusieurs dimensions.
– Le premier élément d’un tableau a toujours pour indice zéro.
– Le nombre de cases du tableau est spécifié au moment de la création du
tableau.
– Le plus grand indice d’un tableau est donc égal au nombre de cases moins un.
– Après sa création les caractéristiques d’un tableau ne peuvent plus être
modifiées (nombre de cases, type d’éléments stockés dans le tableau).
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ La manipulation d’un tableau doit être décomposée en trois étapes :
1. Déclaration d’une variable permettant de manipuler le
tableau.
2. Création du tableau (allocation mémoire).
3. Stockage et manipulation des éléments du tableau.
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Déclaration
– La déclaration se fait comme une variable classique sauf que
l’on doit ajouter à la suite du type de données ou du nom de la
variable les caractères [ et ].
– Il est recommandé, pour une meilleure lisibilité du code,
d’associer les caractères [ et ] au type de données.
– La ligne suivante déclare une variable de type tableau d’entiers.
int[] tableau;
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Création
– Une fois la variable déclarée, il faut créer le tableau en
obtenant de la mémoire pour stocker ces éléments.
– C’est à ce moment qu’il faut indiquer la taille du tableau.
– Les tableaux étant assimilés à des objets, c’est donc
l’opérateur new qui va être utilisé pour créer une instance du
tableau.
– Cette instruction crée un tableau d’entiers indicés de 0 à 11.
tableau = new int [12];
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Création effective en mémoire
– tableauElements = new TypeElement [ taille ] ;
– Exemple :
■ float [ ] tableauReels = new float [ 5 ] ;
■ String [ ] mots ;
■ mots = new String [ 10 ] ;
■ Possibilité de création-initialisation : Il est possible d’effectuer la création et
l’initialisation d’un objet tableau au même moment :
– Lors de la déclaration si les valeurs initiales sont connues.
■ int [ ] fibonacci = { 1, 1, 2, 3, 5, 8, 13, 21 } ;
– // taille du tableau définie implicitement à 8.
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Parcours d’un tableau avec la boucle for
public static void main (String[] args) {
int [] tableau = new int [10] ;
for ( int i = 0 ; i < [Link] ; i ++ ) {
tableau [ i ] = i ;
}
}
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Parcours d’un tableau avec la boucle for … each
– Depuis Java 5
■ adaptée aux collections, tableaux, String (chaines de caractères)
– Syntaxe
for (TypeElement identifiant : reference) {
instructions ;
}
– Exemple
for (int element : tableau) {
[Link] (element);
}
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux - Arguments de méthodes en
nombre variables
■ Depuis Java 5
– Considérons la fonction
public float moyenne (float ... elements) {
float resultat = 0 ;
int size = [Link] ; /* nombre d’arguments */
/* … */
return resultat ;
}
– Cette méthode peut être invoquée avec 0 ou plusieurs paramètres de
types float.
– Les arguments anonymes sont accessibles dans le corps de la méthode
comme s’il s’agissait d’un tableau.
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux - Arguments de méthodes en
nombre variables
■ Depuis Java 5
– La déclaration de telles méthodes peut être accompagnée d’autres
arguments. Dans ce cas :
■ Elle doit être unique
■ Elle doit apparaître uniquement en fin de liste
public float f (float x, float y, float … donnees) { /* … */ }
– Si deux fonctions
public float moyenne (float … elements) { /* … */ }
– et
public float moyenne (float arg_1, float arg_2) { /* … */ }
– sont définies en même temps
■ à l’invocation de : moyenne (4, 89) ; c’est la seconde méthode qui
sera exécutée.
Ghislain AKINOCHO - [Link]@[Link]
Les Tableaux
■ Manipulation des tableaux
– La plupart des opération permettant la manipulation des tableaux sont
disponibles grâce à la classe [Link] fournissant de
nombreuses méthodes static de manipulation de tableaux.
■ Obtenir la taille d’un tableau :
– Il suffit d’utiliser la propriété length du tableau pour connaître le
nombre d’éléments qu’il peut contenir.
■ Rechercher un élément dans un tableau :
– la fonction binarySearch permet d’effectuer une recherche dans
un tableau.
– Elle accepte comme paramètres le tableau dans lequel se fait la
recherche et l’élément recherché dans le tableau.
Ghislain AKINOCHO - [Link]@[Link]
Les Opérateurs
■ Les opérateurs sont des mots clés du langage permettant l’exécution
d’opérations sur le contenu de certains éléments, en général des
variables, des constantes, des valeurs littérales, ou des retours de
fonctions.
■ La combinaison d’un ou de plusieurs opérateurs et d’éléments sur
lesquels les opérateurs vont s’appuyer se nomme une expression.
■ Ces expressions sont évaluées au moment de l’exécution en fonction
des opérateurs et des valeurs qui sont associées.
■ Deux types d’opérateurs sont disponibles :
– Les opérateurs unaires qui ne travaillent que sur un seul
opérande.
– Les opérateurs binaires qui nécessitent deux opérandes
Ghislain AKINOCHO - [Link]@[Link]
Les Opérateurs
■ Les opérateurs unaires
Opérateur Action
- Valeur négative
~ Complément à un
++ Incrémentation
-- Décrémentation
! Négation
■ L’opérateur ! n’est utilisable que sur des variables de
type boolean ou sur des expressions produisant un
type boolean (comparaison).
Ghislain AKINOCHO - [Link]@[Link]
Les Opérateurs
■ Les opérateurs d’affectation
– Le seul opérateur disponible dans cette catégorie est l’opérateur =.
variable = valeur ;
– Il permet d’affecter à une variable une valeur.
– Le même opérateur est utilisé quel que soit le type de la variable
(numérique, chaîne de caractères, etc...).
– Il peut être combiné avec un opérateur arithmétique, logique ou
binaire.
Ghislain AKINOCHO - [Link]@[Link]
Les Opérateurs
■ Les opérateurs arithmétiques
■ Les opérateurs arithmétiques permettent d’effectuer des
calculs sur le contenu des variables.
Opérateur Opération réalisée Exemple Résultat
- Soustraction 15-7 8
+ Addition pour des valeurs numériques ou 1+2 3
concaténation pour des chaînes de caractères
* Addition 8*7 56
/ Division 1/3 0.3333333333
% Modulo (reste de la division entière) 21%7 0
Ghislain AKINOCHO - [Link]@[Link]
Les Opérateurs
■ Les opérateurs de comparaison
– Les opérateurs de comparaison sont urilisés dans les structures de
contrôles (if, do, while, for …).
Opérateur Opération réalisée Exemple Résultat
== Egalité 15 == 7 false
!= Inégalité (Différent) 15 != 7 true
< Inférieur 15 < 7 false
> Supérieur 15 > 7 false
<= Inférieur ou égal 15 <= 15 true
<= Supérieur ou égal 7 >= 8 False
instanceof Comparaison du type de la objet true si la variable objet référence un
variable avec le type instanceof objet créé à partir de la classe Classe
indiqué Classe ou d’une de ses sous-classes
Ghislain AKINOCHO - [Link]@[Link]
Les Opérateurs
■ Les opérateurs logiques
■ Les opérateurs logiques permettent de combiner les expressions
dans des structures conditionnelles ou des structures itératives.
Opérateur Opération Exemple Résultat
réalisée
& Et logique if ((test1) & (test2)) true si test1 et test2 sont vrais
| Ou logique if ((test1) | (test2)) true si test1 ou test2 est vrai
^ Ou exclusif if ((test1) ˆ (test2)) true vrai si test1 ou test2 est vrai mais
pas si les deux sont vrais simultanément
! Négation if (!test) Inverse le résultat renvoyé par test
&& Et logique if ((test1) && (test2)) Pareil que l’opérateur & mais test2 ne
sera évalué que si test1 est vrai
|| Ou logique if ((test1) || (test2)) Pareil que l’opérateur | mais test2 ne
sera évalué que si test1 est faux
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôle
■ Les structures de contrôle permettent de modifier l’ordre
d’exécution des instructions dans le code.
■ Deux types de structures sont disponibles :
– Les structures de branchement (ou de décision) : elles se
brancheront sur un bloc d’instruction ou un autre en fonction
du résultat de l’évaluation de certaines conditions.
– Les structures itérative (ou en boucle) : elles feront exécuter
un bloc d’instructions un certain nombre de fois, jusqu’à ce
qu’une condition soit remplie ou tant qu’une condition est
remplie.
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ Les structures de branchements
– Deux structures sont disponibles
■ La structure if (condition) instruction;
■ SI condition est vraie alors instruction est exécutée.
■ condition doit être une expression qui, une fois
évaluée, fournit un boolean true ou false.
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ La structure if (condition) instruction;
– Avec la syntaxe précédente, seule l’instruction située après
le if sera exécutée si la condition est vraie.
– Pour pouvoir faire exécuter plusieurs instructions en
fonction d’une condition il faut utiliser des accolades pour
délimiter le bloc concerné.
if (condition) {
instructions
}
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ La structure if (condition) instruction;
– Il est possible de spécifier une ou plusieurs instructions qui
elles seront exécutées si la condition est fausse.
if (condition) {
instructions
} else {
instructions
}
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ La structure if (condition) instruction;
– Il est également possible d’imbriquer les conditions.
if (condition1) {
instructions
} else if (condition2) {
instructions
} else {
instructions
}
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ La structure if (condition) instruction;
– Il existe également un opérateur conditionnel permettant
d’effectuer un if ... else en une seule instruction.
– L’opérateur ternaire
condition ? expression1 : expression2 ;
– Cette instruction est équivalente à
if (condition)
return expression1 ;
else
return expression2 ;
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ La structure switch
– La structure switch permet un fonctionnement équivalent
mais offre une meilleure lisibilité du code.
– Elle est plus adaptée lorsque l’évaluation porte sur une
liste de valeurs.
switch (expression) {
case valeur1 : instruction
break;
case valeur2 : instruction
break;
default: instruction
}
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ Les structures itératives
– Trois structures sont à notre disposition :
while (condition) { }
do { } while (condition) ;
for ( ; condition ; ) { }
■ Elles ont toutes pour but de faire exécuter un bloc de code un
certain nombre de fois en fonction d’une condition.
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
int i=0;
while (condition) { while (i<10) {
instructions [Link](i);
i++;
} }
■ La condition est évaluée avant le premier passage dans la boucle.
■ Si elle est false à cet instant alors le bloc de code n’est pas exécuté.
■ Après chaque exécution du bloc de code la condition est à nouveau évaluée
pour vérifier si une nouvelle exécution du bloc de code est nécessaire.
■ Il est recommandé que l’exécution du bloc de code contienne une ou
plusieurs instructions susceptibles de faire évoluer la condition.
■ Si ce n’est pas le cas la boucle s’exécutera sans fin.
■ Il ne faut surtout pas placer de caractère ; après le while car dans ce cas, le
bloc de code n’est plus associé à la boucle.
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
do { do {
instructions [Link](i);
i++;
} while (condition) ; } while (i<10) ;
■ Cette structure a un fonctionnement identique à la précédente sauf que la
condition est examinée après l’exécution du bloc de code.
■ Elle permet de garantir que le bloc de code sera exécuté au moins une fois
puisque la condition sera testée pour la première fois après la première
exécution du bloc de code.
■ Si la condition est true alors le bloc est exécuté une nouvelle fois jusqu’à ce
que la condition soit false.
■ Il faut faire attention à ne pas oublier le ; après le while sinon le
compilateur détecte une erreur de syntaxe.
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
for (initialisation ; condition ; itération) {
instructions
}
for (int i = 0 ; i < 10 ; i ++) {
[Link]( i );
}
■ Lorsque le nombre d’itérations à réaliser dans une boucle est connu il est
préférable d’utiliser la structure for.
■ Pour pouvoir utiliser cette instruction, une variable de compteur doit être
déclarée.
■ Cette variable peut être déclarée dans la structure for ou à l’extérieur, elle
doit dans ce cas être daéclarée avant la structure for.
Ghislain AKINOCHO - [Link]@[Link]
Les structures de contrôles
■ Il faut noter qu’en l’bsence des instructions break et continue
à l’intérieur des accolades, les structures for et while sont
équivalentes.
for (initialisation ; condition ; iteration) {
instruction
}
initialisation ;
while (condition) {
instruction
iteration;
}
Ghislain AKINOCHO - [Link]@[Link]
Les commentaires
■ Comme en langage C et C++, les commentaires Java peuvent se
mettre sur une ligne unique ou sur plusieurs lignes.
■ Tous les caratères du bloc de commentaires sont ignores par le
compilateur Java.
/*
* Ceci est un bloc de commentaires d’implémentation
*/
a = b ; // Un commentaire d’implémentation sur une ligne
/**
* Ceci est un commentaire de documentation
* Déclaration d’un attribut
*/
String attribut ;
Ghislain AKINOCHO - [Link]@[Link]
Les commentaires
de documentation
■ Description du contenu du code
■ Requis par les utilisateurs de ce code
■ Sont exploitées par des outils de génération de documentation (JavaDoc)
■ Marqueurs pour les description de l’usage des paramètres
■ @return >> éléments du langage
■ @param >> description des résultats possibles
■ @throws >> description des types d’erreur en fonction des causes
■ @author >> l’auteur du code concerné
■ @since >> version depuis laquelle ce code est en vigueur
■ @deprecated >> information d’obsolescence
■ @date >> date du code
Ghislain AKINOCHO - [Link]@[Link]
APPLICATION
■ Ecrire un programme Java qui initialise un tableau de 10 nombres réels
avec l’aide de l’utilisateur.
– Explorer les possibilités de la classe Scanner (Consulter la
documentation Java).
■ A l’aide des possibilités offerte par la classe Arrays :
– Trier le tableau
– Rechercher dans le tableau un nombre fourni par l’utilisateur et
afficher sa position dans le tableau.
Ghislain AKINOCHO - [Link]@[Link]
FIN
Next – > Partie III
La programmation Orientée Objet vue de
Java