Premiers programmes
en Java

Avant de commencer

Lors de tous les TDs, lorsque vous trouverez des indications du type suivant :

java.lang.Object

java.lang.String

Cela signifie que vous devez étudier la classe correspondante dans la documentation officielle d'Oracle, Java (API), pour réaliser votre programme ou pouvoir comprendre la question. il s'agit de vous familiariser par vous-même avec la documentation du langage. Celle-ci est exhaustive et très bien faite : Il faut savoir s'en servir !
Profitez-en pour garder cette page dans votre marque page.
Dans ce tp nous n'utiliserons que des classes appartenant au package java.lang

L'environnement de programmation

Pour ces premiers TPs, nous allons utiliser un simple éditeur de texte comme emacs, gedit ou tout autre éditeur capable da faire de la coloration syntaxique. Il s'agit ainsi de se familiariser avec les commandes java et javac, et de bien comprendre comment java fonctionne.

Compiler et exécuter : javac et java

Pour faire un programme en Java, il faut taper son code via l'éditeur de texte sélectionné et de l'enregistrer dans un fichier, par exemple MonProg.java.

Pour compiler le programme il faut taper la commande :

> javac MonProg.java

Cette commande génère un fichier compilé de nom : MonProg.class. Et pour lancer l'exécution de ce programme il faut taper :

> java MonProg

Le code minimal

En Java, tout programme contient au moins une classe publique contenant la méthode public static void main(String[] args). C'est cette méthode qui est exécutée après le lancement de la JVM. Comme vous le verrez plus tard, en règle générale, chaque classe est stockée dans un fichier différent. Le nom du fichier doit être identique au nom de la classe qu'il contient avec en plus l'extension '.java', en respectant les minuscules et les majuscules. Voici le code minimal pour un programme Java :


/**

 * Minimal : illustration du code minimal requis pour un programme Java

 */



/**

 * @author Bob

 *

 */

public class Minimal {



  /**

   * @param args paramètres du programme

   */

  public static void main(String[] args) {

    //votre code ...

  }



}

Remarques :

le symbole // permet d'écrire une ligne de commentaire (ignorée du compilateur).
Comme nous le verrons les symboles /** */ permettent de créer des commentaires qui seront accessibles en ligne. Prenez l'habitude de toujours écrire des commentaires, même pour les classes les plus simples!
Le code précédent doit être enregistré dans un fichier portant le nom Minimal.java

Hello World!

L'exemple suivant est le code complet d'un programme java qui se contente d'afficher la chaîne de caractère : "Hello world!"


/** 

 * The HelloWorldApp class implements an application that

 * simply prints "Hello World!" to standard output.

 */

public class HelloWorldApp {

    public static void main(String[] args) {

        System.out.println("Hello World!"); // Display the string.

    }

}

Exercice 1:

Écrivez, compilez et exécuter le programme précédent.

Notez au passage une méthode très importante en Java :

System.out.println("votre texte");

Cette méthode vous permet d'afficher une ligne de texte. Vous pouvez l'utiliser aussi pour afficher la valeur d'une variable :

int n=5;
System.out.println(n);

Ou encore une chaîne structurée avec un texte et la valeur d'une variable :

int n=5;
System.out.println("La valeur de n est : "+n);

Testez ces différentes utilisations en modifiant la classe HelloWorldApp.

Exercice 2:

Coder la fonction factorielle dans un programme, appelé Factorielle. Ce programme affichera la factorielle de n, n étant une variable de type int dont la valeur est fixée dans le code au moment de sa déclaration ( int n = 5; ). exemple, si n est fixée 5 :

> java Factorielle
factorielle pour n = 5 : 120

Les paramètres d'un programme

Un programme peut recevoir des paramètres que l'on spécifie dans la ligne de commande au moment du lancement de l'exécution du programme. Exemple :

> java Prog p1 p2 p3

Cette ligne de commande lance donc l'exécution du programme Prog avec les paramètres : p1 p2 et p3. Les paramètres sont des chaînes de caractères, séparés les uns des autres par des espaces.

Récupération des paramètres transmis :
Dans le programme les paramètres sont placés dans l'argument args de la méthode public static void main(String[] args), comme vous l'avez remarqué args est un tableau de String, c'est a dire un tableau de chaînes de caractères. Dans l'exemple précédent on aura alors : la chaîne p1 dans args[0] , la chaîne p2 dans args[1] et la chaîne p3 dans args[2].
Rappel : le nombre d'éléments que contient un tableau "tableau" est donné par la valeur tableau.length. Ainsi toujours dans notre exemple : args.length vaut 3.

Exercice 3:

Ecrire un programme appelé AfficheArgs qui affiche tous les paramètres qui lui sont transmis en ligne de commande (un par ligne).

Exercice 4:

Comme vous venez de le voir, un paramètre est toujours du type String. Si on veut qu'un paramètre soit une valeur entière, codée par le type primitif int, il faut faire une conversion du type String vers le type primitif int.
Trouver dans la documentation la méthode qui permet de réaliser cette conversion.

API

java.lang.Integer

Exercice 5:

Écrivez un programme Factorielle2 qui calcule la factorielle d'une valeur n donnée en paramètre au moment du lancement du programme.

Exemple :

> java Factorielle2 3
factorielle pour n = 3 : 6
> java Factorielle2 6
factorielle pour n = 6 : 720

Exercice 6:

Par ailleurs, pour analyser les paramètres passés au programme, il est aussi possible d'utiliser l'une des nombreuses méthodes de la classe String. Trouvez quelle est la méthode qui permet de récupérer les caractères d'une String, individuellement, dans une varible du type primitif char.

API

java.lang.String

Cette méthode pourra par exemple être utilisée dans l'exercice suivant pour récupérer l'opérateur dans une variable de type char afin de réaliser un switch dessus.

Ecrire un programme, appelé Calcul, qui retourne le résultat d'une opération donnée en paramètre, il doit gérer les opérateurs : + - * et / et supporter des opérandes à virgule (on se limitera au cas où seulement 2 opérandes et un opérateur sont donnés en paramètres. Exemple :

> java Calcul 5 + 6.5
11.5

Attention : l'exécution dans une console Unix de la commande :
> java Calcul 3 * 4
provoque une erreur car le caractère * est interprété par le shell et est remplacé par l'ensemble des noms de fichier contenu dans le répertoire courant. Convainquez-vous en exécutant la commande :

> java AfficheArgs *

Il faut donc taper à la place :

> java Calcul 3 "*" 4

Ceci n'a aucune conséquence pour le programme, il recevra toujours les paramètres 3, * et 4.

Exercice 7:

Écrire un programme appelé DernierIndexDans qui, étant donné une string et un caratère, donne la dernière position du caractère dans la string ou -1 si il n'y en a pas. La première position étant numérotée 0.

Exemple :

> java DernierIndexDans testeur e
Le dernier e dans testeur se trouve à la position 4
>> java dernierIndexDans testeur a
Le dernier a dans testeur se trouve à la position -1

API

java.lang.String

Exercice 8:

Écrire un programme appelé TermineAvec, étant donné deux strings, vérifie si la première se termine par la deuxième.

Exemple :

> java termineAvec testeur eur
testeur se termine bien en eur
>> java dernierIndexDans testeur eurr
testeur ne se termine pas en eurr
>> java dernierIndexDans testeur euR
testeur ne se termine pas en euR

API

java.lang.String

Exercice 9:

Écrire un programme appelé TermineAvecIgnorerLaCasse qui fait la même chose mais sans tenir compte de la casse des caractères

Exemple :

> java TermineAvecIgnorerLaCasse testeur eur
testeur se termine bien en eur
>> java TermineAvecIgnorerLaCasse testeur eurr
testeur ne se termine pas en eurr
>> java TermineAvecIgnorerLaCasse testeur euR
testeur se termine bien en euR

API

java.lang.String

Exercice 10:

Ecrire un programme nommé HexadecimalToInteger : un convertisseur hexadécimal -> décimal qui affiche la valeur décimale d'un caractère (un seul) hexadécimal fournit en paramètre. Par ailleurs, le programme doit vérifier que le caractère passé en argument est bien un nombre hexadécimal et le signaler à l'utilisateur dans le cas contraire.

Exemples:

> java HexaToInt A
10

> java HexaToInt G
Erreur: G n'est pas un caractere hexadecimal.

API

java.lang.Integer

Exercice 11:

Améliorer le programme précédent pour qu'il puisse convertir une valeur hexadécimale de plusieurs caractères.

Exemple:

> java HexaToInt B5
181

Exercice 12:

Écrire un programme nommé SystemProperty qui affiche les propriétés de l'OS suivantes : le nom de l'utilisateur, tel qu'il est enregistré dans l'OS, le répertoire de travail courant et le numéro de version de la machine virtuelle utilisée pour lancer le programme

Exercice 13:

Écrire un programme qui crée un tableau d'entier de taille 100 initialisé avec les vingt premiers indexes à 0, les 60 suivants à 2 et les 20 derniers à 8. Ensuite le programme doit afficher le tableau avec le formatage précis suivant : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]

Exercice 14:

Écrire un programme qui copie son fichier source dans un sous répertoire "backup"

Exercice 15:

Écrire un programme qui prend en paramètre une url (e.g. http://www.lirmm.fr) et un nom de fichier. L'objectif est d'enregistrer le fichier correspondant à l'url dans un fichier du nom donné comme deuxième paramètre