Bases du langage

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 :

1    public...

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

1. Les opérateurs unaires

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

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 :

2. Structures de décision

Deux solutions sont possibles.

if (condition)instruction; 

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

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

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

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

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:"); 
     ...