Mémento de la syntaxe de Java

Table des matières

1. La structure générale d'un programme
• Programme sans enregistrements
• Programme avec enregistrements
2. Les composants élémentaires de Java
• Les identificateurs
• Les mots-clefs
• Les commentaires
3. Les types primitifs
• Les constantes entières
• Les constantes flottantes
• Les constantes caractères
• Les constantes chaînes de caractères
• Les constantes symboliques
4. Les opérateurs
• L'affectation
• Les opérateurs arithmétiques
• Les opérateurs relationnels
• Les opérateurs logiques booléens
• Les opérateurs logiques bit à bit
• L'opérateur conditionnel ternaire
• L'opérateur de conversion de type
• La concaténation de chaînes de caractères
• Règles de priorité des opérateurs
5. Le branchement conditionnel
6. Les boucles
• Boucle while
• Boucle do---while
• Boucle for
7. Les instructions d'entrée et de sortie
8. Les fonctions
• Définition
• La fonction main
9. Les enregistrements
10. Les tableaux
11. Les fonctions mathématiques
12. Le système de fichiers d'Unix/Linux
• Les principales commandes
• Les expansions d'arguments
• La redirection des entrées-sorties

1  La structure générale d'un programme

1.1  Programme sans enregistrements

class  NomProgramme 
{
    // déclaration des variables globales
    static  type  nomVariable;

    // définition des fonctions secondaires
    static  type  nomFonction( type1 para1, ..., typeN paraN)
    {
       déclarations de variables locales 
       instructions
       return  valeur;
    }
    // définition de la fonction principale
    public static void main(String[] args) 
    {
       déclarations de variables locales 
       instructions
    }
}

1.2  Programme avec enregistrements

class  NomEnregistrement 
{
    // déclaration des champs
     type nomChamp;
}
class  NomProgramme 
{
    // déclaration des variables globales
    static  type  nomVariable;

    // définition des fonctions secondaires
    static  type  nomFonction( type1 para1, ..., typeN paraN)
    {
       déclarations de variables locales 
       instructions
       return  valeur;
    }
    // définition de la fonction principale
    public static void main(String[] args) 
    {
       déclarations de variables locales 
       instructions
    }
}

2  Les composants élémentaires de Java

2.1  Les identificateurs

• les lettres (minuscules ou majuscules),
• les chiffres,
• le “blanc souligné” (_),
• le dollar ($).

Conventions.

• noms de variables : éviter les noms commençant par _ ou par $ car ils sont habituellement réservés respectivement aux variables systèmes et aux variables d'un code généré automatiquement ;
• noms de fonctions : juxtaposer un verbe en minuscule et un nom débutant par une majuscule (par exemple, parcourirListe) ;
• noms d'enregistrements et noms de programmes : commencer par une majuscule.

2.2  Les mots-clefs

2.3  Les commentaires

Commentaire de fin de ligne :

// Ceci est un commentaire 

Commentaire d'un bloc de code :

/*  Ceci est 
    un commentaire */

Commentaire d'un bloc de code pour la documentation Javadoc :

/**  Ceci est 
     un commentaire */

3  Les types primitifs

3.1  Les constantes entières

• décimale  (par défaut) ;
• octale : les constantes octales commencent par un zéro (ex : 0377) ;
• hexadécimale : les constantes hexadécimales commencent par 0x ou 0X (ex : 0xff).

3.2  Les constantes flottantes

3.3  Les constantes caractères

\n	nouvelle ligne	\r	retour chariot
\t	tabulation horizontale	\f	saut de page
\b	retour arrière

3.4  Les constantes chaînes de caractères

3.5  Les constantes symboliques

4  Les opérateurs

4.1  L'affectation

4.2  Les opérateurs arithmétiques

• La notation / désigne à la fois la division entière et la division entre flottants. Si les deux opérandes sont de type entier, l'opérateur / produira une division entière (quotient de la division). Par contre, il délivrera une valeur flottante dès que l'un des opérandes est un flottant. Par exemple,

  double x;
  x = 3 / 2;
  

  affecte à x la valeur 1. Par contre

  x = 3 / 2.;
  

  affecte à x la valeur 1.5.
  
  
• L'opérateur % est le reste de la division euclidienne. Si l'un des deux opérandes est négatif, le signe du reste est celui du dividende. Cet opérateur s'applique aussi à des flottants. Dans ce cas, la valeur r de a % b est donnée par r = a - bq où q = ⌊ a/b⌋.

4.3  Les opérateurs relationnels

4.4  Les opérateurs logiques booléens

int x = 5, y = 2, z = 3;
boolean r;
r = (x >= 0) && (y != 2) || !(z > 10);

4.5  Les opérateurs logiques bit à bit

4.6  L'opérateur conditionnel ternaire

x >= 0 ? x : -x

4.7  L'opérateur de conversion de type

int i = 3, j = 2;
double r = (double)i/j;

4.8  La concaténation de chaînes de caractères

int i = 3;
System.out.println("i = " + i);

4.9  Règles de priorité des opérateurs

opérateurs
++   --   -(unaire)   ~   !   (type)	←
*   /   %	→
+   -(arithmétiques)   +(String)	→
<<   >>   >>>	→
<   <=   >   >=   instanceof	→
==   !=	→
&(et bit-à-bit)	→
^	→
|	→
&&	→
||	→
? :
=   *=   /=   %=   +=   -=     <<=   >>=  >>>=  &=   ^=   |=	←

Table 1: Règles de priorité des opérateurs

5  Le branchement conditionnel

if ( expression )
  {
    instruction-1
  }
else
  {
    instruction-2
  }

else 
  {
    instruction-2
  }

if ( expression-1 )
  {
    instruction-1
  } 
else if ( expression-2 )
  {
    instruction-2 
         ⋮
  }
else if ( expression-n )
  {
    instruction-n
  }
else
  { 
    instruction-∞
  }

6  Les boucles

6.1  Boucle while

while ( expression )
  {
   instruction
  }

6.2  Boucle do—while

do
  {
    instruction
  }
while ( expression );

6.3  Boucle for

for ( expr-1 ; expr-2 ; expr-3)
  {
    instruction
  }

for (int i=0; i<10; i=i+1)
  {
   System.out.println("Bonjour");
  }

int i = 0;
while (i < 10)
   {
    System.out.println("Bonjour");
    i = i+1;
   }

7  Les instructions d'entrée et de sortie

7.1  Affichage

• System.out.print(expression); affiche la valeur textuelle d'une expression (opère sur les types primitifs, String, Object).
• System.out.println(expression); affichage avec passage à la ligne.

7.2  Lecture

x = Ppl.readInt();

do
   {
      x = Ppl.readInt();
      // instructions
   } 
while (!Ppl.endOfInput());

8  Fonctions

8.1  Définition

    static  type  nomFonction( type1 para1, ..., typeN paraN)
    {
       déclarations de variables locales 
       instructions
       return  valeur;
    }

• type est le type de la valeur retournée par la fonction, donnée comme argument de return. Si la fonction ne retourne aucune valeur, elle est de type void et l'instruction de retour à la fonction appelante est return; (ou omise).
• La fonction travaille sur une copie des valeurs de ses arguments.
• Les méthodes dynamiques, elle, ne sont pas précédées du mot-clef static.

static long facto(int n) 
{
    long resultat = 1;
    for (int i=2; i<=n; i=i+1)
        {
            resultat = resultat * i;
        }
    return resultat;
}

8.2  La fonction main

public static void main(String[] args) 

public static void main(String[] args) 
    {
        String pays = args[0];
        int cp = Integer.parseInt(args[1]);
        String ville = args[2];
              ⋮
    }

java Prog France 91128 Palaiseau

9  Les enregistrements

Définition

class  NomEnregistrement 
{
    // déclaration des champs
    [final]  type  nomChamp;
}

Déclaration d'un enregistrement

Allocation d'un enregistrement

Accès à un champ de la variable enregistrement

Constructeurs

• Le constructeur est une fonction qui porte le même nom que l'enregistrement ;
• Le type de l'objet retourné n'est pas mentionné, et il n'y a pas d'instruction return;
• Il permet par exemple d'affecter les champs de l'objet construit, désigné par this.

class Point
{
    double abscisse;
    double ordonnee;

    Point(double x, double y)
    {
        abscisse = x;
        ordonnee = y;
    }
}

  Point(double abscisse, double ordonnee)
  {
    this.abscisse = abscisse;
    this.ordonnee = ordonnee;
  }

10  Les tableaux

Déclaration

Allocation

Accès aux éléments

Taille d'un tableau

Tableaux multi-dimensionnels

tab = new int[nbLignes][nbCol];

tab = new int[nbLignes][];
for (int i=0; i< tab.length; i=i+1)
    tab[i] = new int[i+1];

11  Les fonctions mathématiques

12  Le système de fichiers d'Unix/Linux

12.1  Les principales commandes

• cd nom_de_repertoire
  Change Directory
  permet de se placer dans le répertoire nom_de_repertoire. Utilisée sans argument, la commande cd replace dans le home directory.
• ls nom_de_repertoire
  liste le contenu du répertoire nom_de_repertoire. Utilisée sans argument, elle liste le contenu du répertoire courant. L'option -a permet de lister également les fichiers dont le nom commence par ., l'option -l affiche les propriétés des fichiers (droits d'accès, propriétaire, taille, date de modification), l'option -t liste les fichiers en les triant suivant la date de la dernière modification.
• mkdir nom_de_repertoire
  MaKe Directory
  crée le répertoire nom_de_repertoire.
• rmdir nom_de_repertoire
  ReMove Directory
  supprime le répertoire nom_de_repertoire, à condition qu'il soit vide.
• cp fichier_depart fichier_arrivee
cp fichier1 [ fichier2 fichier3...] repertoire_arrivee
  CoPy
  Si les deux arguments sont des noms de fichier, la commande copie le fichier désigné par le premier argument dans le fichier désigné par le second. Si le dernier argument est un répertoire existant, tous les fichiers désignés par les arguments précédents sont copiés dans ce répertoire.
• mv fichier_depart fichier_arrivee
mv fichier1 [ fichier2 fichier3...] repertoire_arrivee
  MoVe
  déplace des fichiers. La syntaxe est identique à celle de cp.
• rm fichier1 [ fichier2 fichier3...]
  ReMove
  supprime le ou les fichiers donnés en arguments.
• pwd
  Print Working Directory
  affiche le répertoire courant.

12.2  Les expansions d'arguments

• ? qui peut être remplacé par n'importe quel caractère ;
• * qui peut être remplacé par une chaîne quelconque de caractères (incluant la chaîne vide).

12.3  Redirection des entrées-sorties

• L'opérateur > redirige la sortie standard vers un fichier. Par exemple, avec java Prog > fichier_sortie tout ce qui est affiché à l'exécution de Prog est écrit dans le fichier fichier_sortie. De la même manière, ls > fichier, écrit le résultat de la commande ls dans le fichier fichier.
• L'opérateur < redirige l'entrée standard vers un fichier. Par exemple, avec java Prog < fichier_entree les données lues au cours de l'exécution de Prog ne sont plus celles entrées au clavier mais celles qui se trouvent dans le fichier fichier_entree.

This document was translated from L^AT_EX by H^EV^EA.