UHP - ESSTIN -  Département  d' Informatique

 

Mémento de traduction

L.A.O.  |  Java 6   

(c) ~/2A env.  -   Dernière  MAJ :  01.02.2011  08:45 / H. Nguyen-Phu

 

 

Schéma-bloc typique (cadre à développer avant  toute traduction en Java ! )

 

  uneClasse  // nom de la classe


  // Bloc des attributs  (ou donnée-membres ou  champs)

  +  unChampPublic: TypeC  // ‘public Attribute’ A éviter !

  #  unChampProtégé: TypeC // ‘protected Attribute’ : accès par des classes dérivées venant de tout paquet

  ~  unChampParDéfaut: TypeC // ‘package Attribute’ : visible au sein du même paquet  

  -  unChampPrivé: TypeC // ‘private Attribute’ A faire pour bien encapsuler !
  …

 

   // Sous-bloc des constructeurs :

  + uneClasse( )  {  // sans arguments

    ... // le contenu peut être vide pour empêcher toute instanciation…

  }

  + uneClasse(D   objetSource : uneClasse )  {  // avec un argument unique

    ... // du même type pour copier intégralement l’objet source

  }

  + uneClasse(D arg1 : Type1, . . .  )  { // avec un ou plusieurs arguments

    . . .  // pour instancier un ou des champs du bloc des attributs

  }

  + uneClasse(D  objetEquivalent : autreClasse )  {// avec un argument unique

    ... //  de type ‘autreClasse’ afin d’effectuer une conversion adéquate

  }

  // Sous-bloc des accesseurs (méthodes d’accès en lecture seule) :

  +  accèsUnChampPrivé() : TypeC   {

        RETOURNER    unChampPrivé

  }

  . . .

  // Sous-bloc des modifieurs (méthodes modificatrices) :

   + modifierUnChampPrivé(D  nouvelleValeur : TypeC)   {

        unChampPrivé  <- nouvelleValeur

  }

// Sous-bloc  des autres méthodes (de classe)

    . . .

  + PROCEDURE principale(D  args : TABLEAU de CHAINE)  {// méthode de classe

   ...  // pour tester le bon fonctionnement des méthodes ci-dessus

  }

____________________________________________________________________________



     


 
 
 
 

     


 

 

Héritages  & Algorithmique Objet   (A compléter  ...)

 

Ceci.nomAttribut  <-   nomAttribut

Super.uneMéthode(…)


 this.nomAtrribut =  nomAttribut;

super.uneMéthode(…);

 

 

Commentaires:  

   Ils sont définis après  deux  slashs  "//"    ou    entre  /*  ... */   ou   entre    /** ...  */ pour ‘ javadoc ’. 

 

 

 

Gestion  des  E/S standards (A compléter et améliorer via un TPP ...)

A INCLURE 'java.io.*' par:        import java.io.*;

A inclure aussi  (cf. Java 5.0) :                 import static java.lang.System.*; 

 




 


octet : OCTET   // signé

ECRIRE(«octet=? »)
LIRE(octet)

 

i : ENTIER COURT

ECRIRE(« i = ? » )
LIRE(i)


a : ENTIER

ECRIRE(« a = ? » )
LIRE(a)

b : ENTIER LONG
ECRIRE(« b = ? » );  LIRE(b)

//Copier d'abord 'es.java'
//dans le dossier courant; Ex. '~/tppXY'

// cp /home/info/tpp/2a/java/es.java  ~/tppXY/.

byte octet= Byte.parseByte(es.LireCh(«octet=? »));


short i = Short.parseShort(es.LireCh(« i = ? » ));


int a = Integer.parseInt(es.LireCh(« a = ? » ));


 long b = Long.parseLong( es.LireCh(« b= ? »));

ECRIRE(b)

out.println(b); 

// <=>  System.out.println(b);  

// pour version antérieure à Java 5.0            

a, b: CARACTERE 
LIRE (a, b)

char a, b;   a=  (char) in.read();
// <=>   a=   es.LireCh().charAt(0);  
b=  (char) in.read();
//  <=>  b=   (char) System.in.read();

//       pour   version antérieure à Java 5.0

 

ECRIRE("a= ", a," b= ",b) 

out.println("a= "+ a +" b= " + b);


uneCond: BOOL         
LIRE(uneCond)  
// A traduire via  'ESSAI ... CAPTURE'

 

A : REEL 

ECRIRE(« A = ? »)
LIRE(A)


  float A = Float.parseFloat( es.LireCh(« A = ? »));
//  à partir de la version JDK 1.2 ...  ou


//  String  str = es.LireCh(« A = ? »);
// float  A=Float.valueOf (str).floatValue();
//  si  c'est la version JDK 1.1  (ou Visual J++)

a : REEL  DOUBLE 
ECRIRE(« a = ? »)

LIRE(a)


 double a=Double.parseDouble(es.LireCh(«a= ?»));
// à partir de la version JDK 1.2 ...    ou

//   String txt = es.LireCh(« a = ? »);
// double  a=Double.valueOf(txt).doubleValue();
// si c'est la version JDK 1.1  (ou Visual J++)
 

 

 

 Emploi de la classe ‘Scanner’ de JDK 1.5 pour la saisie  au  clavier 

Avant JDK  5.0,   utiliser  ‘JOptionPane.showInputDialog’ par exemple ou via  la classe ‘es.java’

 

import java.util.* ;

…

Scanner jin = 

    new Scanner(System.in);

 

System.out.print(“Taper  qqc :  ”);

 

import  javax.swing.*;

…

String txt= JOptionPane.showInputDialog(“Taper  qqc:  ”);

 

// ou   String  txt = es.LireCh(“Taper qqc: ”);

 

int m = jin.nextInt();

int  m = Integer.parseInt(txt);

long n = jin.nextLong();

 

long n = Long.parseLong(txt);      

float  x = jin.nextFloat();

 

float x = Float.parseFloat(txt);      

double x = jin.nextDouble();

 

double x = Double.parseDouble(txt);      

String mot= jin.next();

 

String mot = txt;      

String phrase =

       jin.nextLine();  

 

cf. test_scan et vscanner.java                  

 

String phrase = txt;      

 

 

 

Emploi de la méthode  ‘printf’ de JDK 5.0 pour  formater la sortie   (cf.  ‘printf’ du langage C)

Avant JDK  5.0,   utiliser  par exemple  ‘NumberFormat.getNumberInstance’. 

 

System.out.printf(“%8.2f”, x);

NumberFormat forma = NumberFormat.getNumberInstance();

forma.setMinimumFractionDigits(2);

forma.setMaximumFractionDigits(2);

String formatted = forma.format(x) ;

for(int i = formatted.length(); i < 8; i++)

      System.out.print(“  “);

System.out.print(formatted);

Il existe aussi :   “%d    %9.2e    %14.7e   %23.16 e   …    %s”   etc…

cf.  consulter  les menus ‘tpp’  ou ‘lju’ sous Linux  pour plus de détails …

 

Déclarations

 

a : OCTET //<=>‘int8’ de Matlab 7 

a : ENTIER COURT // ‘int16’                              

a : ENTIER       // ‘int32’
a : ENTIER LONG  // ‘int64’ 

byte  a; // 8-bits signed integer

short a; // short signed integer
int a;   // signed integer <=> 32 bits
long a;  // long signed integer

b : REEL
b : REEL DOUBLE

float b;  // cf. norme IEEE 754
double b; // cf. norme IEEE 754

c : CARACTERE
c <-  'H' 

char c; // format Unicode: 16 bits
c ='H'; // on affecte 'H' dans c

 

 

T : TABLEAU[0...9] de ENTIER

 

int t[] = new int[10];
int []t = new int[10];

 

 

VRAI : Valeur bool. prédéfinie

 

FAUX : Valeur bool. prédéfinie

 

C : CONSTANTE ENTIERE = 80

 

 

Pi: CONSTANTE REELLE = 3,141593

 

E : CONSTANTE REELLE DOUBLE = exp(1)                            

PI: CONSTANTE REELLE DOUBLE =                                                                  4*Arctg(1)

 

 

true

 

false

 

       final int     C = 80;
static final int     C = 80;

       final float   Pi = 3.141593f;
static final float   Pi = 3.141593f;

 

Math.E    // ou E  avec 16 digits exacts

Math.PI   // ou PI avec 16 chiffres exacts
// si inclusion statique au préalable de :

import static  java.lang.Math.*;

// cf. Java 5.0  vs.  Java 1.4

ch: CHAINE;

ch <- RES CHAINE("Bonjour G2j !")

c <- ch.iemeCAR(0) //c=‘B’ici !
Ch: CHAINE CONSTANTE = "Hello !"

 

String ch = new String("Bonjour G2j !");

c = ch.charAt(0); // c == ’B’
final String  Ch = "Hello !";

Point = PCART (abs: REEL, ord: REEL)
// PCART <=> classe publique !
unPoint : Point

class  Point {public float abs; public float ord;};

Point unPoint;

 

o : OCTET // <=> 8 bits


uneCondition: BOOLEEN // ou BOOL 

 

byte o; //smallest signed int. <=> 8 bits


boolean uneCondition; // taille= 8 bits


  Affectations

 

a <- 1  

a = 1;

a <- a + 1

a = a + 1; // a += 1; a++;  ++a;   

a <- a - 1

a = a - 1; // a -= 1; a--;  --a;

a <- a + b

a = a + b; // a += b;

a <- a * b

a = a * b; // a *= b;

a <- a / b   // a, b: REELS
a <- a DIV b // a, b: ENTIERS

a = a / b; // a /= b;

a <- a MOD b // a <- a modulo b
//MOD: reste de la division entière

a = a % b; // a %= b;


  Conditionnelles

 

a = b

a == b  // ATTENTION ERREUR FREQUENTE: '=='

a <> b

a != b

a > b

a > b

a >= b

a >= b

a < b

a < b

a <= b

a <= b

NON a

!a

(condition1) ET (condition2)

((condition1) && (condition2))

(condition1) OU (condition2)

((condition1) || (condition2))

SI (condition) ALORS

if(condition){ // accolades

   ... // A indenter !

 ...}          // inutiles si 
               // instruction unique ! 

SINON

else {

   ... // A indenter !

    ...  // A indenter !

FSI   // ou  FINSI

} // Noter que FSI est implicite!


  Boucles

 

TANTQUE (condition) FAIRE  

while (condition) {

   ...  // A indenter !

   ...  // A indenter !

FTQ  // ou FINTantQue

} 

POUR i DE deb A fin FAIRE

for(int i=deb; i<=fin; i++) {

   ...  // A indeneter !

   ...  // A indenter !

FPOUR

} 

POUR j DE fin A deb FAIRE

for (int j=fin ; j=deb; j--) {

   ...  // A indenter !

   ...  // A indenter !

FPOUR

} 

POUR [CHAQUE] e PARMI E FAIRE

for (e  :  E )  {     // A partir de Java 5.0 ...

   ...  // A indenter !

   ...  // A indenter !

FPOUR  // e : un élément de E

}  // cf. exemple:  moyenne.java


 

 

REPETER   

 do {

   ... 

   ... 

JUSQU'A (Cond) 

} while (!Cond); 

 

// Noter bien le NON(Cond)

/*
Exercice en L.A.O.: Trouver les équivalences
strictes entre les  boucles  ci-dessus et
la boucle  "FAIRE  . . .  TANTQUE( Cond. )".
*/

/**  Même exercice en Java:
 *   Trouver les équivalences strictes
 *   entre les
 *   trois boucles itératives.
 * @author  HNP
 * @version 0.95
 */

// Création de menu  pour choix multiples
// via des boucles "sans fin" du type:
ITER  {  ...   }   FITER //  Fin ITER

 
     for(;;) {...}  
     while (true) { ... }
     do { ... } while (true);

lichaTest  :  CLASSE   {  //  publique

   PROC.  MAIN(D  a : TAB de CHAINE)

    //  de classe  (i.e.  ‘static’) et  publique 

   DEB // de la méthode principale ‘MAIN’
     uneListe:  licha
     uneListe <- RES  licha()

     choix:  ENTIER ;  rep :  CHAINE
     ITER
         ECRIRE("Listes chaînées ...")
      //  A  COMPLETER ...

 

 

 

 

 

 

 

 

 

 

 

     
          ECRIRE("SVP, votre choix : ");    
          LIRE(choix)

          CAS  (choix)
        0 :  RUPTURE //pour sortir 'CAS..FCAS'
        1 :  uneListe.ajout_tete();     RUPTURE
        2 :  uneListe.supp_tete();     RUPTURE  
        3 :  uneListe.ajout_queue(); RUPTURE
        4 :  uneListe.supp_queue(); RUPTURE
        5 :  uneListe.afficher();       RUPTURE
        AUTRECAS:                      RUPTURE
          FCAS
          SI (choix  <= 0  OU choix >5) ALORS
                RUPTURE  // pour quitter ... 

          FSI
     FITER
   PAUSE
  FIN  // de la méthode principale ‘MAIN’

}  // fin de la classe  ‘lichaTest’

 

 

 

 

import static java.lang.System.*;   // Inclusion statique ... cf.  Java 5.0

import java.util.*;   // cf.  ‘Scanner’

import java.io.*;

public class lichaTest  {
  public static void main (String[] a)   {
  //   'licha' : classe publique déjà définie au préalable  (cf. cours 1A-S2 2009-10) ...

        licha   uneListe = new  licha();

    Scanner jin = new Scanner(System.in);

        int choix;
        for( ; ; ) {    
            out.println("Listes chaînées ...");
            out.println("------ Date  = ...  MAJ par  . . .  \n");
            out.println("0) Pour quitter ... ");
            out.println("1) Ajout en tete");
            out.println("2) Supp. en tete");
            out.println("3) Ajout en queue");
            out.println("4) Supp. du dernier");
            out.println("5) Affichage du contenu");
            choix = jin.nextInt();
            switch (choix)   {
              case 0 : break;  // RUPTURE de séquence
              case 1 : uneListe.ajout_tete();  break;
              case 2 : uneListe.supp_tete();  break;
              case 3 : uneListe.ajout_queue();  break;
              case 4 : uneListe.supp_queue();  break;
              case 5 : uneListe.afficher();  break; 
              default:   break;
            }
            if (choix <= 0 || choix > 5)     break;  
        }
  }   // fin de la méthode ‘main’
}    //  fin de la classe  ‘lichaTest’

 

// Pour obtenir le guide 'tpp' via le serveur, taper  sous  Windows:  
Cliquer sur ‘ssh  poincare3’          

(pour accéder à poincare3)
// puis:        mot de passe
// et enfin:   tpp   et/ou  lju

 


// Pour accéder au champ public  'MonCar'
tete -->  MonCar   // du PCART  'maillon'                                               

// Pour accéder au champ encapsulé 'InfoUtile'
tete-->  InfoUtile  // de la classe 'li_cell'


tab[tete].MonCar // si implanté par le tableau tab[]
tete.MonCar  // si tete est une référence sur 'maillon'

tab[tete].getInfo() // si implanté par le tableau tab[]
tete.getInfo() // si tete est une référence sur 'li_cell'

Tableaux  unidimensionnels

 

a : TABLEAU(1..10) de ENT
i : ENTIER   

int a[] = new int[10]; // En C++: int a[10];

POUR i DE 1 A 10 FAIRE

for (int i=0; i < 10; i++) {

   a[i] <- 0
   ...

     a[i] = 0;
     ...  // autres instructions ...

FPOUR

} // Noter bien le décalage de 0 à 9 en Java !


Tableaux  bidimensionnels

 

A: TABLEAU(0...9)(0...9)de REEL
i, j: ENTIER 

float [][]A = new float[10][10];
int i, j;

POUR i DE 0 A 9 FAIRE
  POUR j DE 0 A 9 FAIRE

for (i=0; i < 10; i++)  
   for (j=0; j < 10; j++)  {

    A[i][j] <- (REEL)(i + j)
    ... // autres instructions

      A[i][j] = (float) (i+j);
      ...

  FPOUR
FPOUR

   }// Noter bien les décalages de 0 à 9 !
// accolades inutiles si instruction unique pour "for(i=...)"


 Procédures

 

PROCEDURE swap(D/R a: REEL, D/R b: REEL)

 public void swap (//A COMPLETER)

DEBUT 

{  // A COMPLETER

    tmp: REEL

   

    tmp <- a;  a <- b;  b <- tmp;

   

FIN   

}

//ATTENTION au passage de paramètres!

Appel : swap(x, y)
// x et y sont BIEN échangés

 // cf.   ‘tpp’  ou ‘lju’   sous poincare3


  Fonctions

 

FONCTION fct(D p1: REEL, D p2: REEL): REEL

 public float fct(float p1, float p2)

DEBUT 

{

    i,  j : ENTIER  //  etc ...

 int i, j;   // etc ...

    fct  <- p1 ^ p2
 // ou RETOURNER (p1^p2)

 return ( (float) pow(p1, p2) ); 

//ou Math.pow pour versions JDK 1.4 et antérieures…

FIN

}

Module appelant:    c <- fct(a, b)

c = fct(a, b);

 
Fonctions retournant un tableau

 

TYPE Tab= TABLEAU(0...99)DE ENT

FONCTION GenAlea(): Tab

// ENT = ENTIER  'int'  en Java

public int [] GenAlea()

DEBUT 

{

          Tmp:   Tab

  int [] Tmp = new int[100];

   //génération des ENTIERS entre 0 et 20

     ...

     Tmp[99] <- hasard(21)
     GenAlea <--  Tmp

  // même génération du tableau

  ...
  Tmp[99] = (int)random()*21;

  return Tmp; //ou Math.random()…

FIN

}

monTab: Tab   // SSP appelant
monTab  <- GenAlea()

  int [] monTab = GenAlea();



Gestion  des  exceptions (A compléter  pour les principaux types d’exceptions ...)

 

ESSAI
  {
      // Bloc d'instructions
  }

CAPTURE (D  te1:  TypeException1)
    {
      // Bloc d'instructions
  }
CAPTURE (D   te2:  TypeException2)
    {
      // Bloc d'instructions
  }

...
ENFIN 

    {
      // Bloc d'instructions
  }


try   {
      //  Bloc d'instructions
}
  catch (TypeException1   te1)  {
      // Bloc d'instructions
  }
  catch (TypeException2  te2)   {
      // Bloc d'instructions
 }

. . .
  finally  {
    // Bloc d'instructions
}

  Exemples  d’emploi :  cf.  ‘/home/info/tpp/2a/java/facrec.java’   par le serveur  ‘poincare3’
ou   ‘ lect_fic.java ’  (lecture d’un fichier texte)