Cours JAVA

Cours JAVA : execution d'un programme JAVA


Télécharger Cours JAVA : execution d'un programme JAVA

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Cours JAVA : exécution d'un programme JAVA

...

2.4.2 Execution d’un programme Java

Source Compilation Execution

On crée un document source avec une extension .java, par exemple Toto.java On compile le(s) fichier(s) source(s) avec le programme javac, par exemple javac Toto.java. Si la compilation a réussi, un fichier .class Toto.class est créé, ce fichier est constituéde byte code L’exécution est lancée en utilisant le programme java avec le nom du fichier principal du programme sans l’extension .class. Par exemple java Toto.

2.4.3 La machine virtuelle

Un programme s’exécute en lançant la JVM sur le fichier principal (Toto.class). Ce fichier contient du byte code et la JVM traduit ce byte code en code machine compréhensible par la plateforme sous-jacente et exécute le programme.

Lorsque la JVM démarre elle cherche la classe spécifiée à l’exécution, puis elle recherche une méthode spéciale – la méthode main – qui ressemble exactement à ceci :

public static void main(String [] args) {

//le code de la methode main

1 La JVM exécute ensuite tout ce qui se trouve entre les accolades{ } de la méthode main.

2.4.4 La méthode main

Toute application java a au moins une méthode main. Attention, pas une par classe, mais au moins une par application. La méthode main correspond à l’endroit oùle programme commence à s’exécuter.

Voici un exemple de programme complet :

public class PremiereAppli{

public static void main(String [] args)

{ System.out.println("Bonjour à tous");

System.out.println("Je m’appelle toto");

  1. Enregistrement dans le fichier PremiereAppli.java
  2. Compilation javac PremiereAppli.java
  3. Lancement du programme java PremiereAppli
  4. Le résultat du programme consiste à afficher les 2 lignes suivantes : Bonjour à tous Je m’appelle toto

2.4.5 Utilisation d’arguments dans la fonction main

Les arguments de la méthode main sont placés dans le tableau args, qui est un tableau constituéde chaînes.

Lors du lancement d’un programme, les arguments se placent à la suite de l’identificateur de classe du programme lancéet sont séparés par un espace. Exemple:

java AfficheArguments Le langage Java

Voici le programme correspondant :

public class AfficheArguments{

public static void main(String [] args)

{

for(int i=0;i<args.length;i++)

{ System.out.println("contenu de args[" + i +"] "+ args[i]);

} }}

A l’exécution, ce programme affiche le résultat suivant :

contenu de args[0] Le

contenu de args[1] langage

contenu de args[2] Java

N.B. Les arguments sont passés sous la forme de chaînes de caractères, si nous voulons des nombres nous devons convertir les arguments.

Exemple.

public class Addition2Entiers{

public static void main(String [] args) {

int entier1, entier2, resultat;

entier1=Integer.parseInt(args[0]); entier2=Integer.parseInt(args[1]);

resultat = entier1 + entier2;

System.out.println("La somme de "+entier1+" et "+entier2+" est "+resultat);

} }

Pour lancer le programme : java Addition2Entiers 1 3. Autre exemple.

public class ConversionFrancsEuros{ public static void main(String [] args) {

final float taux = 6.55957f;

float somme = 0f, resultat;

somme=Float.parseFloat(args[0]); resultat = somme / taux;

System.out.println("Le resultat de la convertion de "+somme+"

francs est "+resultat+" euros.");

}}

2.5 Installation et utilisation de Java

Pour installer un outil de développement java, il suffit de récupérer un outil de développement (JDK ou SDK) sur …, puis de lancer le programme d’installation. Sous linux vous pouvez l’installer par exemple dans /usr/local pour le rendre accessible à tout le monde, ou sous votre compte.

Ensuite nous allons principalement utiliser les programmes situés dans le répertoire bin  /Chemin Installation/jdk1.8.0 10/bin (/Chemin Installation correspondant au répertoire d’installation de java), par exemple si vous avez récupéréla version 10 du jdk 1.8 - javac, java, javadoc, jar, ...). Pour faciliter leur utilisation vous pouvez mettre le répertoire bin dans votre variable d’environnement PATH (cf le cours système). Notez que sous certains systèmes linux/unix, certaines distributions java sont pr´e-installées, mais ne correspondent pas aux versions officielles fournies par Sun Microsystems.

Pour écrire nos programmes nous aurons seulement besoin d’un éditeur (par exemple emacs sous linux, ou tout un autre éditeur si vous le souhaitez) et d’un terminal (xterm).

Vous pourrez éventuellement avoir de besoin de configurer une variable d’environnement CLASSPATH qui indique les répertoires oùsont situés les programmes java. Ce n’est pas obligatoire, par défaut les programmes sont cherchés dans le répertoire courant et il est possible d’indiquer des répertoires en spécifiant des options aux différents programmes disponibles dans le jdk (voire la documentation officielle indiquée dans les liens ci-dessous).

Quand vous serez plus expérimenté(par exemple à partir du 4ème TP), vous pourrez essayéd’autres éditeurs facilitant le développement de programmes java tels qu’eclipse ou NetBeans. A

vous de les essayer et éventuellement d’en adopter un. Néanmoins, il est d’abord conseilléd’utiliser un éditeur non spécifique pour commencer, puis de passer à un éditeur spécialiséune fois que l’on maîtrise les bases du langage.

Pour ceux qui souhaitent essayer leurs programmes sous windows, la procédure d’installation est la même. Il peut cependant être nécessaire de créer une variable d’environnement supplémentaire. Voici la procédure à suivre.

— Vérifier que la variable d’environnement JAVA HOME est spécifiée.

— Si ce n’est pas le cas allez dans Menu Démarrer → Settings → Control Panel → System → Advanced, menu variables d’environnement. Entrez le nom de JAVA HOME puis sa valeur (par exemple C:2sdk1.8.0 10/).

— Pour vérifier tapez echo %JAVA HOME dans une console MS-DOS.

Vous pouvez utiliser la même méthode pour modifier le contenu de la variable PATH ou configurer CLASSPATH. En guise de terminal vous utiliserez alors une console MS-DOS.

 2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTRÔLE FONDAMENTALES 15

2.6 Types, expressions et structures de contrôle fondamentales

Cette partie a pour objectif de présenter rapidement l’utilisation des types, des expressions et des instructions de contrôle en JAVA. Les éléments abordés ne sont pas forcément toujours caractéristiques du langage JAVA mais sont nécessaires pour l’utilisation de n’importe quel langage de programmation. Lorsque certaines situations sont spécifiques au langage JAVA, nous le précisons.

2.6.1 les types primitifs

Ils servent à définir les champs (attributs) de toutes les classes que vous pourrez définir, ainsi que les variables que vous pourrez utiliser dans les différentes méthodes. Attention, les types primitifs ne sont pas des classes.

La notion de type

La mémoire centrale est un ensemble de ” positions binaires ” appelées. Ces bits sont regroupés en octets, un octet correspondant à 8 bits. Les ordinateurs (actuels) ne savent représenter et traiter que des informations représentées sous forme binaire. Il est donc nécessaire de savoir comment une information a étécodée pour pouvoir attribuer une signification à une suite de bits d’un emplacement de la mémoire.

Il existe 4 catégories de type primitif en JAVA :

— nombres entiers

— nombres flottants

— caractères

— booléens

le type entier (int)

Il sert à représenter les nombres entiers relatifs. Il existe quatre sortes d’entier permettant de représenter des valeurs différentes. Le tableau suivant décrit chacun de ces types avec le nom du type, la taille occupée en mémoire en octets, la valeur minimale et la valeur maximale possible avec la constante correspondante dans le langage.

...

Les constantes peuvent s’écrire sous forme décimale (548, -78, +5), ou sous forme hexadécimale en précisant la valeur de 0x ou 0x (0x1A 0X12), ou octale en faisant précéder la valeur de 0 (032, 05).

Une constante entière est forcément de l’un des types int ou long. On peut forcer une constante à être du type long en faisant suivre sa valeur de la lettre l ou L, exemple 25L. Le compilateur rejettera toute constante ayant une valeur supérieure la capacitédu type long.

Les flottants/réels (float ou double)

Il en existe deux sortes. Le tableau suivant décrit chacun d’eux avec leur nom, la taille occupée en mémoire en octets, la précision correspondant au nombre de chiffres significatifs pris en compte dans la partie décimale, la valeur minimale et la valeur maximale possible avec la constante correspondante dans le langage.

...

Pour les constantes, il existe deux notations :

— la notation décimale : 12.43 -0.38 -.38 4. .27

— la notation exponentielle : 4.25E4 ou 4.25e+4 pour 4.25 x 104

54.2e-32 pour 54.2 x 10−32

48e13 pour 48 x 1013

Par défaut toutes les constantes créées sont de type double, pour forcer à avoir un type float

on fait suivre la valeur de la lettre f, exemple : 12.5f

Le type caractère (char)

Les caractères, désignés par le type char, sont codés sur 2 octets, notation d’une constante caractère: ’a’, ’B’, ’é’, ’+’. Exemple char lettre=’a’;

Certains caractères avec notation spéciale :

— ’\b’ pour le retour arrière (backspace)

— ’\t’ pour une tabulation

— ’\n’ pour un saut de ligne

— ’\f’ pour un saut de page

— ’\r’ pour un retour chariot

— ’\"’ pour un guillemet

— ’\’’ pour une apostrophe

— ’\\’ pour \.

Le type booléen (boolean)

Il sert à représenter une valeur logique de type vrai ou faux, il existe deux valeurs possibles pour un booléen en java : true et false (pour vrai et faux). Exemple boolean est ordonne=false;.

Attention, en JAVA, les valeurs logiques ne sont pas représentées par des valeurs mais par un type spécifique : le type boolean, toute utilisation de valeur numérique dans des tests provoquera une erreur!

Initialisations et constantes

Variables Exemples : int n=15; également équivalent à int n; n=15;.

En JAVA, les déclarations peuvent apparaître à n’importe quel endroit du programme. D’un point de vue méthodologique, il est souvent conseilléd’effectuer la déclaration de toutes les variables (importantes) ensembles au début puis de les initialiser avant de les utiliser. N.B. Les variables n’ayant pas reçu de valeur ne peuvent pas être utilisées sous peine d’aboutir à une erreur de compilation. Il est donc important de penser à initialiser les variables dès leur création.

 2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTRÔLE FONDAMENTALES 17

Constantes: le mot cléfinal Pour indiquer qu’une variable ne peut pas être modifiée pendant l’exécution d’un programme, on peut utiliser le mot cléfinal :

final int nombre de mois=12;

Toute modification de la variable nombre de mois, de valeur initiale 12, sera rejetée par le compilateur.

2.6.2 Opérateurs et expressions Opérateurs arithmétiques

Il existe cinq opérateurs principaux :

— + : addition a+b

— - : soustraction a-b

— / :division a/b

— * : multiplication a*b

— % : modulo, a % b calcule le reste de la division de a par b.

Le problème de la conversion de type :

float x; float res;

int n; int p;

res=n*x+p;

La variable n étant de type int, x de type float, le compilateur va convertir n en float puis faire le calcul. Le résultat final sera de type float, comme le montre la Figure 2.1.



float  + float

float

FIGURE 2.1 – Evaluation de res=n*x+p;

La hiérarchie de conversion permettant de ne pas dénaturer la valeur initiale : int → long

→ float → double.

Note: par défaut, pour les types byte, char, short, si un de ces types apparaît dans une expression,

la valeur est d’abord convertie en int. Exemple :

short p1=1, p2=1 ,p3=1;

float x=2;

L’évaluation de p1*p2+p3*x est faite comme le montre la Figure 2.2.

...

Opérateurs de comparaison

Ils servent à faire des comparaisons relatives et sont principalement utilisés dans les tests conditionnels.

— < : inférieur strictement à — <= : inférieur ou égal à — > : supérieur à — >= : supérieur ou égal à — == : égal à — ! = : différent de.

Ces opérateurs peuvent s’utiliser avec des expressions : 2 * a > b + 5, x + y < (a + 2) * 5, ... Note : ordre sur les caractères '0' <' 1' < ... <' 9' <' A' <' B' < ... <' Z' <' a' < ... <' z'.

Opérateurs logiques

Ces opérateurs permettent de manipuler des valeurs logiques.

— ! : négation

— & : ”ET”

— n : ”OU” exclusif

— | : ”OU” inclusif

— && :”ET” avec court-circuit

— || : ”OU” inclusif avec court-circuit

Exemples :

— (a < b) && (c < d), (a < b) & (c < d) : ces deux expressions prennent la valeur true (vrai)

si les deux expressions a < b et c < d sont toutes les deux vraies, la valeur false (faux) dans

le cas contraire.

— (a < b) || (c < d), (a < b) | (c < d) : prend la valeur true si l’une au moins des deux

conditions a < b ou c < d est vraie, la valeur false dans le cas contraire.

— (a < b) n (c < d) prend la valeur true si une et une seule des deux conditions a < b et

c < d est vraie, la valeur false dans le cas contraire.

— !(a < b) prend la valeur true si la condition a < b est fausse, la valeur false dans le cas

contraire. Cette expression possède en fait la même valeur que a >= b.

— Les deux opérateurs && et || possèdent une propriété intéressante : leur second opérande (celui qui figure à droite de l’opérateur) n’est évalué que si la connaissance de sa valeur est indispensable pour décider si l’expression est vraie ou fausse. Par exemple, si on a

l’expression (a < b)&&(c < d), on commence par évaluer (a < b), si le résultat est faux on n’évalue pas c < d puisque le résultat est déjàconnu. Les opérateurs n et | évaluent toujours les deux opérandes, il est donc plutôt conseilléd’utiliser les opérateurs && et ||.

Opérateurs d’affectation

— = : exemples c=b+3; c=i;. L’opérateur possède une associativitéde gauche à droite, ainsi dans l’expression i = j = 5; on évalue j=5 d’abord, puis i=j, i et j ont à la fin la même valeur 5.

Attention aux problèmes de conversion, supposons que nous ayons une variable de type int n et une variable de type float x, l’expression n=x+5; est rejetée par le compilateur. Il faut en fait écrire n=(int) x + 5;. Il est nécessaire de faire une conversion explicite. Les conversions pour lesquelles il n’y a pas besoin de faire une conversion explicite sont les suivantes :

— byte → short → int → long → float → double

— char → int → long → float → double

— L’incrémentation et la décrémentation. Ces opérations consistent respectivement à augmenter une variable (en général entière) 1 et à diminuer une variable de 1 (i = i-1; n = n+1;). Ces opérations sont définies par les opérateurs ++ et -- : i--; n++; ou --i; ++n;.

2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTRÔLE FONDAMENTALES 19

Il existe cependant un différence suivant oùest placél’opérateur lors de l’évaluation d’une expression, s’il est placéavant(on parle d’opérateur préfixé) la variable l’opération est effectuée avant l’évaluation de l’expression, s’il est placéaprès (on parle d’opérateur postfixé) l’opération est effectuée après.

— n= ++i -5; : on affecte d’abord la valeur 6 à i puis la valeur 1 à n.

— n= i++ - 5; : on affecte d’abord la valeur 0 à n puis la valeur 6 à i.

— Affectation élargie, les instructions suivantes sont équivalentes

:

— i = i + k; eti+=k;

Il existe la même chose avec les opérateurs *, / et -.

Conversion de types

Lorsque l’on désire convertir un type vers autre qui a une taille de représentation inférieure, les règles suivantes s’appliquent :

— entier vers entier (long vers int, short vert byte, ...) les octets les moins significatifs sont conservés.

— double vers float : arrondi au plus proche.

— flottant vers entier: il y a d’abord un arrondi au plus proche dans le type long ou int, puis on effectue la conversion en conservant les octets les moins significatifs.

Opérateur conditionnel

condition? etape1 : etape2; : si condition est vraie alors etape1 sinon etape2. Exemple : max = a

Si a < b, alors la variable max reçoit la valeur de la variable b, sinon elle reçoit la valeur de la variable a.

...

2.6.3 Les structures de contrôle

Dans cette partie, les crochets [] signifient que ce qu’ils renferment est facultatif. Il servent soit à exprimer le fait que pour lier plusieurs instructions à une structure de contrôle il est nécessaire de mettre ces instructions dans un bloc entre accolades ({}) (si on n’a besoin que d’une seule instruction on n’a pas besoin de bloc) ; soit à indiquer qu’une instruction facultative.

Le terme condition correspond à une expression qui peut être évaluée sous forme logique (vrai ou faux).

if

L’instruction if (si) est une instruction de choix.

if(condition)

[{]

instruction\_1 [instruction\_2

...

instruction\_n }]

[else [{]

instruction\_1 [instruction\_2 ...

instruction\_n }]

Exemple :

public classTva {

public static void main(String [] args)

{

double taux_tva=21.6;

double ht, ttc, net, taux_remise, remise;

ht=200.5;

ttc=ht * (1.0 + taux_tva/100.0);

if(ttc < 1000.0)

taux_remise=0.;

else if(ttc < 2000)

taux_remise=1.;

else if(ttc < 5000){

taux_remise=2.;

System.out.println("Message: Prix ttc entre 2000 et 5000");

}else{

taux_remise=5.;

System.out.println("Message: Prix ttc superieur a 5000");

}

remise = ttc * taux_remise/100; net = ttc - remise;

System.out.println("Prix ttc: "+ttc); System.out.println("Remise: "+remise); System.out.println("Net a payer: "+net);

}}

switch

L’instruction switch (branchement) est une instruction de choix, permettant de tester plusieurs valeurs d’une expression. L’expression peut être de type byte, short, char ou int. Syntaxe :

2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTRÔLE FONDAMENTALES 21

switch(expression)

{ case constante-1: [suite d’instructions1] case constante-2: [suite d’instructions2]

case constante-n: [suite d’instructionsn] [default: suite d’instructions]

}

Exemple :

public class ExSwitch{

public static void main(String [] args) {

int n;

n=Integer.parseInt(args[0]);

switch(n)

{

case 0: System.out.println("zero"); break;

case 1: System.out.println("un"); break;

case 3: System.out.println("trois");

default: System.out.println("Rien"); System.out.println("Fin");

}

System.out.println("Fin du programme");

}}

while

Il s’agit d’une boucle tant que qui exécute un ensemble d’instructions tant qu’une condition est vraie.

Syntaxe :

while(condition) [{]

instruction-1 [instruction-2

...

instruction-n

}]

Exemple

public class Boucle{

public static void main(String [] args)

{

int x=1;

System.out.println("Avant la boucle");

while(x<4)

{

System.out.println("Dans la boucle, la valeur de x est "+x);

x=x+1;

}

System.out.println("Après la boucle");

}}

do-while

Il s’agit d’une boucle faire-tant que similaire à la boucle while sauf que la condition est évaluée après chaque parcours de boucle. La boucle do-while est exécutée au moins une fois, alors que la boucle while peut ne jamais être exécutée.

Syntaxe :

do [{]

instruction_1

[instruction_2

...

instruction_n }] while(condition);

N.B. Il y a un point virgule à la fin de l’instruction ! Exemple :

public class Boucle2{

public static void main (String [] args){

int x=1;

System.out.println("Avant la boucle");

do{

System.out.println("Dans la boule, la valeur de x est "+x);

x=x+1;

}while(x<4);

System.out.println("Après la boucle");

}}

for

L’instruction for est une boucle (pour) dont la syntaxe est divisée en trois expressions. Syntaxe :

for([initialisation] ; [condition] ; [incrémentation])

[{]

instruction_1

[instruction_2

...

instruction_n

}]

— initialisation est une déclaration ou une suite d’expressions quelconques séparées par

des virgules, cette partie est évaluée une seule fois avant d’entrer dans la boucle. — condition est une expression booléenne (logique) quelconque, cette partie conditionne la



poursuite de la boucle et est évaluée avant chaque parcours.

— incrémentation est une suite d’expressions quelconques séparées par des virgules, cette partie est évaluée à la fin de chaque parcours.

 2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTRÔLE FONDAMENTALES 23 Exemple classique:

public class ExFor1

{

public static void main (String args [])

{

int i;

for(i=1; i<=5; i++)

{

System.out.println("bonjour");

System.out.println(i + "fois");

}}}

Remarque: l’exemple précédent est équivalent à public class ExFor2

{

public static void main (String args []) {

int i;

i=1;

while(i<=5)

{

System.out.println("bonjour"); System.out.println(i+"fois"); i++;

}}}

Autre exemple:

public class ExFor3

{

public static void main(String args [])

{

int i,j;

for(i=1, j=3;i<=5; i++, j+=i)

{

System.out.println("i= " +i+ "j= " +j);

} }}

Ce dernier exemple pourrait également être écrit de la manière suivante :npublic class ExFor4

{

public static void main(String args [])

{for(int i=1, j=3;i<=5; i++, j+=i)

{System.out.println("i= " +i+ "j= " +j);

}} }

Les instructions break et continue

Ces instructions s’emploient principalement au sein de boucles.

L’instruction break (casser) sert à interrompre le déroulement d’une boucle en passant à l’instruction située après la boucle. L’exécution de cette instruction est conditionnée par un choix. Exemple :

public class ExBreak

{public static void main (String args [])

{int i;

for(i=1;i<=10;i++)

{System.out.println("debut tour"+i);

System.out.println("bonjour");

if(i==3) break;

System.out.println("fin tour"+i);}

System.out.println("apres ma boucle")

}}

Le résultat du programme précédent est le suivant :

debut tour 1 bonjour fin tour 1 debut tour bonjour fin tour 2 debut tour 3 bonjour

apres la boucle

En cas de boucles imbriquées, l’instruction break fait sortir de la boucle la plus interne. L’instruction continue permet de passer directement au tour de boucle suivant. Exemple.

public class ExContinue

{public static void main (String args[])

{int i;

for(i=1; i<=5; i++)

{

System.out.println("debut tour"+i);

if (i<4) continue;

System.out.println("fin tour"+i);

}

System.out.println("apres la boucle");

 }}

Exemple d’exécution :

debut tour 1 debut tour 2 debut tour 3 debut tour 4 fin tour 4

debut tour 5 fin tour 5

apres la boucle

2.6.4 Les éléments spécifiques au langage JAVA

Parmi les points abordés ci-dessus, quatre sont plutôt spécifiques au langage JAVA.

— Le mot cléfinal qui permet de déclarer des constantes à l’aide de variables.

— Le type byte qui permet de représenter des entiers entre -128 et 127.

— Le type boolean pour représenter les valeurs true (vrai) et false (faux). Tous les tests conditionnels doivent être compatibles avec le type boolean. Mettre une valeur entière dans un test provoque une erreur de compilation en JAVA (par exemple if(1)... est interdit en JAVA).

— Les conversions de type doivent être explicites en JAVA chaque que l’on veut convertir un type général vers une représentation plus petite. Exemple :

int n=2; float x=1.0;

...

n=(int) x;

Un autre élément est traitéde manière spécifique en JAVA : le type chaîne de caractères (String). Une introduction est proposée dans la section suivante.

2.7 Une première introduction au type String

En JAVA, les chaînes de caractères sont définies par un type spécifique: le type String. Nous présentons ici une courte introduction, nous reviendrons sur ce type plus tard.

Déclaration

String chaineSalutation = "bonjour";

Une chaîne de caractère constante se déclare toujours entre guillemets "... ".

Connaître la longueur d’une chaîne

int l = chaineSalutation.length();

Accès à un caractère

char cara1 = chaineSalutation.charAt(0); char cara1 = chaineSalutation.charAt(2);

La variable cara1 contient le caractère b, la variable cara2 contient le caractère n.

Concaténation : l’opérateur +

String ch1 = "Bonjour"; String ch2 = " à tous"; String ch = ch1 + ch2;

La variable ch contient la chaîne ”Bonjour à tous”. Impression d’une chaîne de caractères

System.out.println(chaineSalutation); System.out.println(ch1+ch2); System.out.println(ch);

Comparaison de chaînes La méthode equals qui teste l’égalitéde deux chaînes de caractères: ch1.equals(ch2) ou ch1.equals("Bonjour").

La méthode compareTo pour comparer deux chaînes de caractères dans l’ordre lexicographique (alphabétique) : ch1.compareTo(ch2)

— renvoie un entier strictement négatif si ch1 est située avant ch2 dans l’ordre lexicographique — renvoie un entier strictement positif si ch1 est située après ch2 dans l’ordre lexicographique — 0 si ch1 contient la même chaîne que ch2.

2.8 Règles d’écriture d’un programme JAVA

Ce document a pour objectif de synthétiser les règles d’écriture généralement utilisées pour le développement d’applications en JAVA.

2.8.1 Les identificateurs

Les identificateurs sont des suites de caractères servant à désigner les entités manipulées par un programme (variables, méthodes, classes, objets, ...). En JAVA, un identificateur est forméde lettres et de chiffres ou du caractère . Le premier caractère est forcément une lettre A-Z, a-z ou éventuellement . Il n’existe aucune limitation sur le nombre de caractères.

Exemples :

ligne, valeur 5, total, 56, ma variable 1, i, MaClasse, ... Attention, on distingue les minuscules des majuscules (ligne =~ Ligne).

Certaines conventions sont traditionnellement utilisées :

— Les noms de variables et de méthodes sont écrits en minuscule sauf s’ils sont formés de la juxtaposition de plusieurs mots, auquel cas chaque sous-mot, sauf le premier, comporte une majuscule à la première lettre. Exemples : valeur, nombreValeur, tauxEmprunt, calculNombreReponsesExactes, getX2, ...

— Les noms de classe suivent la même règle, mais leur première lettre est écrite en majuscule. Exemples : PremierProgramme, Clavier,

CalculMoyenne, ...

Remarque : cette convention permet de distinguer le fait que System est une classe et que out n’en est pas une (System.out.println).

— Des identificateurs successifs doivent être séparés par un espace ou un saut de ligne quand il n’y a pas de séparateur ou de syntaxe particulière. Exemple : x = a + 5; y += 4; Une virgule est utilisée pour faire plusieurs déclarations d’un même type. Exemple :

int x, y;

float n, compteur, total, valeur;

2.8.2 Commentaires

Il existe trois types de commentaires en JAVA.

— les commentaires commençant par /* et se terminant par */, exemple : /* Ceci est un commentaire usuel*/

— les commentaires de fin de ligne //, exemple :

int valeur; // valeur avec commentaire de fin de ligne

— les commentaires de documentation commençant par / * * et finissant par */. C’est un cas particulier des commentaires usuels puisqu’ils commencent de manière légèrement différente par rapport à ces derniers. Leur intérêt est de pouvoir être extrait automatiquement pour faire de la documentation avec, par exemple, le programme javadoc.

...

2.8.4 Remarques globales

— Les instructions se terminent par un point virgule ;.

— Les blocs de code sont définis entre accolades {}.

— On déclare une variable avec un nom et un type: int x;.

— Un opérateur d’affectation est avec un seul signe : =.

— Un opérateur d’égalitéest avec deux signes : ==.

— Lorsque l’on écrit du code, il est impératif de respecter les règles d’indentation : les instructions à l’intérieur d’un bloc doivent être décalées à droite, c’est également lorsque l’on utilise une structure de contrôle. La définition de méthodes et d’attributs de classes doivent être indentés par rapport à la définition de la classe elle-même.

— Pensez à commenter votre code et à bien décrire ce que font vos fonctions et à quoi servent vos classe!

— . . .

2.8.5 Commentaires sur le rendu d’un programme Java

Pour rendre un projet vous devez construire une archive (zip, tar.gz) contenant les différents éléments de votre projet. Une archive correctement constituée devrait contenir :

— une bonne documentation comprenant

— un Fichier README contenant des informations pour lancer le projet, l’installer, les pré-requis éventuels et qui documente le contenu de l’archive (liste des fichiers et différents répertoires et ce qu’il y a dedans).

— un manuel utilisateur indiquant comment utiliser le logiciel

— un manuel technique sur la conception du projet (notamment à destination des développeurs) contenant - par exemple - des schémas UML (au moins une description du code constituant le projet), les points à améliorer, les bugs, les difficultés, les choix .... Pour des projets java, la documentation technique peut idéalement être complétée par une javadoc (important pour continuer le développement plus tard).

— une architecture correcte : idéalement à la racine on a le README et que des sous-répertoires contenant la documentation, le code exécutable, le code source, les drivers, plus d’autres choses tout le temps dans un sous-répertoire spécifique et documenté



377