Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Java
  3. Bases du langage
Extrait - Java Les fondamentaux du langage (avec exercices pratiques et corrigés)
Extraits du livre
Java Les fondamentaux du langage (avec exercices pratiques et corrigés)
3 avis
Revenir à la page d'achat du livre

Bases du langage

Anatomie d’un programme

On a coutume de dire que « Tout est objet en Java ». Cela signifie que pour écrire le moindre programme, il est nécessaire de créer au moins une classe dont la structure doit être la suivante :

1    public class NomDeLaClasse 
2    { 
3        //LE CODE DE VOTRE PROGRAMME 
4        public static void main(String[] args) 
5        { 
6            //LE CODE DE VOTRE PROGRAMME 
7        } 
8        //LE CODE DE VOTRE PROGRAMME 
9    } 

Pour plus d’informations sur la création d’une telle classe, veuillez vous référer au chapitre précédent au niveau de la section Premier programme.

Le point d’entrée de votre programme est la méthode main dont la signature doit être celle présentée dans l’exemple à la ligne 4. Le code de cette méthode est délimité par les accolades ouvrantes et fermantes des lignes 5 et 7.

Cette méthode est incluse dans une classe dont la déclaration est réalisée à la ligne 1. Le code de la classe se situe entre les accolades ouvrantes et fermantes des lignes 2 et 9.

Tous les exemples de ce chapitre respecteront cette...

Les variables

1. Introduction

Les variables permettent de mémoriser pendant l’exécution d’une application différentes valeurs utiles à son bon fonctionnement. Avant d’utiliser des variables dans un programme, il convient de savoir où les déclarer, quel nom leur donner et quel type leur donner. C’est l’objectif des prochaines sections.

2. Les emplacements

Les variables en Java peuvent être déclarées n’importe où dans le programme. Il n’y a pas d’emplacements réservés. Cela dit, il y a juste une règle à respecter : les variables doivent être déclarées uniquement entre les accolades délimitant les classes, les interfaces ou les énumérations. Elles ne peuvent pas être en dehors de ces éléments.

Une variable doit obligatoirement être déclarée avant son utilisation dans le code. En fonction de l’emplacement de sa déclaration, une variable appartiendra à une des catégories suivantes :

  • Déclarée à l’intérieur d’une classe, la variable est une variable d’instance. Elle n’existera que si une instance de la classe est disponible (autrement dit un objet). Chaque instance de classe aura son propre exemplaire de la variable.

  • Déclarée à l’intérieur d’une classe avec le modificateur static, un mot-clé du langage, la variable est une variable de classe. Elle est accessible directement par le nom de la classe et n’existe qu’en un seul exemplaire, quel que soit le nombre d’objets créés à partir de cette classe.

  • Déclarée à l’intérieur d’une méthode, la variable est une variable locale. Elle n’existe que pendant l’exécution de la méthode et n’est accessible que par le code de celle-ci.

  • Les paramètres des méthodes peuvent être considérés comme des variables locales. La seule différence réside dans l’initialisation de la variable qui est effectuée lors de l’appel de celle-ci. La structure de programme suivante permet de visualiser l’emplacement de ces différentes catégories de variables :

1    public...

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. 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. Il est obligatoire d’initialiser la constante au moment de sa déclaration (c’est le seul endroit où il est possible de faire une affectation à la constante).

final double TAUXTVA=1.20; 

La constante peut être alors utilisée dans le code à la place de la valeur littérale qu’elle représente.

prixTtc=prixHt*TAUXTVA; 

Les règles concernant la durée de vie et la portée des constantes sont identiques à celles concernant les variables.

La valeur d’une constante peut également être calculée à partir d’une autre constante.

final int TOTAL=100;  
final int DEMI=TOTAL/2; 

De nombreuses constantes sont déjà définies au niveau du langage Java. Elles sont définies comme membres static des nombreuses classes du langage. Par convention, les noms des constantes sont orthographiés entièrement en majuscules.

Les énumérations

Une énumération va nous permettre de définir un ensemble de constantes qui sont fonctionnellement liées entre elles. La déclaration se fait de la manière suivante :

public enum Jour  
{  
   DIMANCHE,  
   LUNDI,  
   MARDI,  
   MERCREDI,  
   JEUDI,  
   VENDREDI,  
   SAMEDI  
} 

La première valeur de l’énumération est initialisée à zéro. Les constantes suivantes sont ensuite initialisées avec un incrément de un. La déclaration précédente aurait donc pu s’écrire :

public class Jour  
{  
   public static final int DIMANCHE=0;  
   public static final int LUNDI=1;  
   public static final int MARDI=2;  
   public static final int MERCREDI=3;  
   public static final int JEUDI=4;  
   public static final int VENDREDI=5;  
   public static final int SAMEDI=6;  
} 

C’est approximativement ce que fait le compilateur lorsqu’il analyse le code de l’énumération.

En fait, la déclaration d’une énumération est une déclaration...

Les arguments d’un programme

1. Fonctionnement

Il est possible de passer des arguments à un programme pour que celui-ci adapte son comportement en fonction des valeurs fournies.

Les arguments fournis sont disponibles dans le tableau de chaînes de caractères nommé args en paramètre de la méthode main.

Pour passer des arguments lors de l’exécution du programme, il suffit d’exécuter le programme avec l’outil java, et d’ajouter, après le nom du programme, les arguments sur la même ligne de commande. Le séparateur est l’espace. Ainsi la commande suivante initialise le paramètre args avec un tableau composé de trois cases :

java MonProgramme arg1 arg2 arg3 

Le tableau args contient les chaînes de caractères suivantes : arg1, arg2 et arg3.

Si un argument contient un espace dans sa valeur, il suffit de délimiter la valeur avec des guillemets :

java MonProgramme arg1 arg2 "arg 3" 

Le tableau args contient dans ce cas les chaînes de caractères suivantes : arg1, arg2 et arg 3.

Si un argument contient un guillemet, il suffit de l’échapper avec le caractère \ :

java MonProgramme arg1 arg2 "arg \"3\"" 

Le tableau args contient dans ce cas les chaînes de caractères suivantes : arg1, arg2 et arg "3".

Pour plus d’informations...

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.

Les opérateurs peuvent être répartis en sept catégories.

1. Les opérateurs unaires

Opérateur

Action

-

Valeur négative

~

Complément à 1 (inversion des bits)

++

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).

Les opérateurs unaires peuvent être utilisés avec la notation préfixée, dans ce cas l’opérateur est placé avant l’opérande, et avec la notation postfixée, dans ce cas l’opérateur placé après l’opérande. La position de l’opérateur détermine le moment où celui-ci est appliqué sur la variable. Si l’opérateur est préfixé, il s’applique sur l’opérande avant que celui-ci ne soit utilisé dans l’expression. Avec la notation postfixée, l’opérateur n’est appliqué sur la variable qu’après utilisation de celle-ci dans l’expression. Cette distinction peut avoir une influence sur le résultat d’une expression.

L’exécution de l’exemple suivant affiche 3 car l’incrémentation est exécutée après utilisation de la variable par l’instruction println :

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

L’exécution de l’exemple...

Les structures de contrôle

1. Présentation

Les structures de contrôle permettent de contrôler l’exécution des instructions dans votre code. Deux types de structures sont disponibles :

  • Les structures de décision : elles aiguilleront l’exécution du code en fonction des valeurs que pourra prendre une expression de test.

  • Les structures de boucle : elles feront exécuter une portion de code un certain nombre de fois, jusqu’à ce qu’une condition soit remplie ou tant qu’une condition est remplie.

2. Structures de décision

Deux solutions sont possibles.

a. Structure if

Quatre syntaxes sont utilisables pour l’instruction if.

if (condition)instruction; 

Si la condition vaut true alors l’instruction est exécutée. La condition doit être une expression qui, une fois évaluée, doit fournir un booléen (true ou false). Avec cette syntaxe, seule l’instruction située après le if sera exécutée si la condition vaut true. Pour exécuter plusieurs instructions en fonction d’une condition, il faut utiliser la syntaxe ci-après.

if (condition)  
{  
     instruction 1;  
     ...  
     instruction n;  
} 

Dans ce cas, le groupe d’instructions situé entre les accolades sera exécuté si la condition vaut true.

Vous pouvez également spécifier une ou plusieurs instructions qui seront exécutées si la condition vaut false en ajoutant un bloc else.

if (condition)  
{  
     instruction 1;  
     ...  
     instruction n;  
}  
else  
{  
     instruction 1;  
     ...  
     instruction n;  
} 

Vous pouvez également imbriquer les conditions avec la syntaxe suivante :

if (condition1)  
{  
     instruction 1  
     ...  
     instruction n  
}  
else if (condition 2)  
{  
     instruction 1  
     ...  ...

Exercices

1. Exercice 1

Créer un tableau de dix chaînes de caractères puis remplir ce tableau avec des adresses e-mail. Calculer ensuite, à partir des informations présentes dans le tableau, la part de marché de chacun des fournisseurs.

Indice : dans une adresse e-mail, le nom du fournisseur est la partie située après le caractère @.

2. Exercice 2

Générer trois nombres aléatoires compris entre 0 et 1000, puis vérifier si vous avez deux nombres pairs suivis par un nombre impair. Si ce n’est pas le cas, recommencer jusqu’à ce que vous ayez la combinaison pair, pair, impair. Afficher ensuite le nombre d’essais nécessaires pour obtenir cette combinaison.

Indice : la classe Random propose un ensemble de méthodes permettant d’obtenir un nombre aléatoire. Concentrez-vous sur la méthode suivante en lisant la javadoc :

public int nextInt​(int bound) 

Pour utiliser cette méthode, il est nécessaire d’avoir un objet de type Random :

Random rd = new Random(); 
rd.nextInt(…); 

3. Exercice 3

Générer un nombre aléatoire compris entre 0 et 1000. Demander ensuite à l’utilisateur de deviner le nombre choisi par l’ordinateur. Il doit saisir un nombre compris entre 0 et 1000 lui aussi. Comparer le nombre saisi avec celui choisi par l’ordinateur...

Corrections

1. Exercice 1

Voici une proposition (et ce n’est qu’une proposition) pour résoudre ce premier exercice. Le code est agrémenté d’un grand nombre de commentaires pour bien comprendre la démarche entreprise. Le code a été écrit dans une seule méthode pour se focaliser sur l’algorithme. Une amélioration peut consister à découper ce programme en méthodes.

import java.util.Arrays; 
 
public  class Exercice1  
{      
 
    static String[] adresses; 
    static String[] listeBruteFournisseurs; 
    static String[] listeFournisseursDistincts;  
    static int[] nombreClients; 
 
    public static void main(String[] args)  
    {  
         //INITIALISATION DU TABLEAU 
        adresses=new String[10];  
        adresses[0]="jpp@sfr.fr";  
        adresses[1]="tom@gmail.com";  
        adresses[2]="fred@sfr.fr";  
        adresses[3]="victor@sfr.fr";  
        adresses[4]="chris@sfr.fr";  
        adresses[5]="robert@orange.fr";  
        adresses[6]="paul@sfr.fr";  
        adresses[7]="lise@gmail.com";  
        adresses[8]="thierry@eni.fr";  
        adresses[9]="marie@eni.fr";  
         
        //RECUPERATION DES FOURNISSEURS DE CHAQUE ADRESSE 
        listeBruteFournisseurs =new String[10];  
        for (int i=0;i<adresses.length;i++)  
        {  
            //Pour chaque adresse, récupération de la chaine après le @: 
            listeBruteFournisseurs[i]= 
adresses[i].substring(adresses[i].indexOf('@')+1); 
        }  
        System.out.println("Liste brute des fournisseurs:"); 
     ...

Conclusion

Vous disposez à présent des techniques de base pour écrire des algorithmes (déclaration des variables, utilisation des opérateurs disponibles et utilisation des structures de contrôle). Pour progresser, il faudra passer des heures à découvrir les fonctionnalités offertes par l’API Java. Rapidement, vous allez avoir besoin de connaître les bases de la programmation objet pour approfondir vos connaissances. C’est l’objectif du prochain chapitre.