Tableau d'équivalence entre pseudo-langage et Java

Tableaux d’équivalence langage algorithmique
et langage Java
Équivalence des structures de programmation en pseudo-langage
et en Java
Pseudo-Langage
Langage Java
Variable a : entier //largeur
int a ; //largeur
Variable c : réel simple //prix
float c ; //prix
Variable d : réel double //prix
double d ; //prix
Variable e : caractère //code
char e ; //code
Constante TVA = 19.6 : réel
final double TVA=19.6;
Variable S en chaîne
String S;
a5
/*a variable déclarée et de type
compatible avec 5*/
ba*3 + c
/*a, b et c variables déclarées
et de type compatible*/
a=5 ;
Déclaration
Affectation
/*Forme générale (nécessite que
la classe Lire.java soit dans
le répertoire de compilation)*/
nom_variable_à_lire=Lire.
premiere_lettre_du type() ;
//Forme générale
Lire(nom_variable_à_lire)
Lecture
//Exemple
Lire(a)/*on suppose a variable
de type entier*/
//Affichage d’un libellé
Ecrire (“Il fait beau”)
Ecriture
b=a*3 + c ;
//Exemple
a=Lire.i();/*on suppose a
variable de type int*/
/*Affichage d’un libellé +
retour à la ligne*/
System.out.println(“Il fait
beau”);
/*Affichage valeur d’une
variable + retour à la ligne*/
System.out.println(a);
//a variable déclarée
/*Affichage valeur d’une
variable*/
Ecrire(a)
//a variable déclarée
//Libellé + valeur de variable
Ecrire (La surface du rectangle
vaut ”, surf, “!”)
//surf variable déclarée
1
/*Libellé + valeur de variable
et retour à la ligne*/
System.out.println(“La surface
du rectangle vaut ”+
surf+“!”) ;
//surf variable déclarée
Si test Alors
instructions1
instructions2
if (test){
instruction1;
instruction2;
}
else{
instruction3;
instruction4;
Sinon
Tests
instructions3
instructions4
...
FinSi
Si test Alors
instruction1
instruction2
...
FinSi
Liste de cas
Selon valeur faire
valeur1 : instruction1
valeur2 : instruction2
…
valeurn : instructionn
sinon inst_par_défaut
FinSelon
/*valeur est soit un entier soit
un caractère*/
La boucle
TantQue
while (condition){
...
Instruction1 ;
Instruction2 ;
...
}
TantQue condition Faire
…
Instruction1
Instruction2
…
FinTantQue
Pour var de init à fin [pas=n] faire
La boucle
Pour
}
if (test){
instruction1;
instruction2;
...
}
switch (valeur){
case valeur1 : {
instruction1;
break ;
}
case valeur2 : {
instruction2;
break ;
}
…
case valeurn : {
instructionn ;
break ;
}
default : inst_par_défaut ;
}
instruction1
instruction2
...
FinPour
for (var=init; var<=fin; var+=n){
instruction1 ;
instruction2 ;
...
}
2
Équivalence Tableaux/matrices langage algorithmique et Java
Pseudo-Langage
Java
Déclaration/création Tableau t[20] en Entier
d’un
Tableau //20 taille du tableau,
//indices commencent à 0
statique
Déclaration
/
création
d’une
Matrice statique
int [] t=new int [20] ;
/*t.length donne la
taille de t ici 20*/
Tableau t[2,3] en Entier
/*2 nombre de lignes,3 nombre
de colonnes, indices
commencent à 0*/
int [][] t=new
int[2][3] ;
/*t.length donne le nb
de lignes ici 2 et
t[0].length donne le nb
de colonnes ici 3*/
Équivalence sous-programme langage algorithmique et Java
Pseudo-Langage
Java
Procédure affiche(
V : entier)
Variable
res : entier
Début
res = 2*v
Ecrire res
Fin affiche
public static void affiche (int v)
Appel à une
procédure
(appel à la
procédure
affiche)
affiche(2)
affiche(a) /*a variable
déclarée et initialisée
de type compatible avec
un entier*/
Fonction qui
retourne un
entier (le carré
d’un entier
passé comme
paramètre)
Fonction carre (v :
entier) : entier
Variables
res : entier
Début
res = v*v
carre res
Fin carre
/*la procédure affiche est dans la
même classe que le ss-prog appelant
*/
affiche(2) ;
affiche(a) ; /*variable déclarée et
initialisée de type compatible avec
un int*/
public static int carre (int v){
Procédure
(affiche le
double du
nombre passé
comme
paramètre)
Appel à une
fonction (appel
à la fonction
carre)
{
int res;
res = 2*v;
System.out.println(res);
}
int res;
res = v*v;
return res ;
acarre(2) /*a variable
déclarée de type
compatible avec un
entier*/
acarre(3*4+b*3) /*a, b
variables déclarées de
type compatible avec un
entier, b initialisée*/
3
}
/*la fonction carre est dans la
classe du sous-programme appelant*/
a=carre(2) ; /*a variable déclarée
de type compatible avec un int*/
a=carre(3*4+b*3) ; /*a, b variables
déclarées de type compatible avec
un int, b initialisée*/
Équivalence sous-programme langage algorithmique et Java
avec des tableaux
Les tableaux sont passés par référence en Java c’est-à-dire que l’on travaille directement sur les
éléments de tableau passés en paramètre d’entrée.
Pseudo-Langage
Procédure avec
tableau en
entrée (affiche
les éléments du
tableau donné
en entrée)
Java
public static void affichage (int[]
t, int n)
Procédure affichage(t :
tableau d’entier, n :
entier)
Variable
i : entier
Début
{
int i;
for(i=0 ; i<n ; i++){
System.out.print(t[i]+”\t”);
}
Pour i de 0 à n-1 faire
Ecrire t[i]
FinPour
Appel à une
procédure
ayant un
tableau en
entrée (appel à
la procédure
affichage)
Fonction avec
un tableau en
entrée (la
somme des
passé comme
paramètre)
Fin affichage
affichage(tab, 3)
/*tab est un tableau
d’entier, l’appel à
affichage affiche les 3
premiers éléments de
tab*/
}
/*la procédure affichage est dans
la même classe que le ss-prog.
appelant */
affichage(tab, 3) ;
/* tab est un tableau d’entier,
déclaré et initialisé ; l’appel à
affichage affiche les 3 premiers
éléments de tab */
Fonction somme (t :
tableau d’entier, n :
entier) : entier
Variables
i,s : entier
Début
s0
public static int somme (int[] t,
int n){
int i,s;
s=0;
for(i=0 ; i<n ; i++){
ss+t[i]
}
return s;
Pour i de 0 à n-1 faire
ss+t[i]
FinPour
ssomme
Fin affichage
Appel à une
fonction avec
un tableau en
entrée (appel à
la fonction
somme)
}
/*la fonction somme est dans la
classe du sous-programme appelant*/
somsomme(tab,3) /*tab
est un tableau d’entier
déclaré et initialisé,
som est une variable
entière déclarée*/
som=somme(tab,3) ; /*tab est un
tableau d’entier déclaré et
initialisé, som est une variable
entière déclarée ; l’appel à somme
calcule la somme des 3 premiers
éléments de tab */
4
Fonction avec
tableau en
sortie (crée et
remplit un
tableau avec les
entiers de 1 à n)
Pseudo-Langage
Java
Fonction
suite
(n :
entier) : 1 tableau d’entier
public static int[] suite (int n){
Variables
i : entier
res
[n] :
Tableau
d’entier
//abus
du
pseudo-langage
Début
int [] res = new int [n] ;
int i;
for (i=0 ; i<n ; i++){
res[i] = i+1;
}
return res;
Pour i de 0 à n-1 faire
Appel à une
fonction ayant
un tableau en
entrée (appel à
la fonction
suite)
res[i]  i+1
FinPour
suite res
Fin suite
tabsuite(5)
/*tab
est
un
tableau
d’entier
déclaré,
d’au
moins 5 éléments, l’appel
à suite remplit tab avec
les entiers de 1 à 5 */
5
}
/*la fonction suite est dans la
même classe que le ss-prog.
appelant */
tab = suite (5) ;
/* tab est un tableau d’entier,
déclaré et initialisé l’appel à
suite remplit tab avec les entiers
de 1 à 5 */