TPs Java 2022

Ecole Mohammadia d'Ingénieurs Génie Informatique
Département Informatique 1ère Année
Travaux Pratiques de la
Programmation Orientée
Objets : Java
Asmae EL KASSIRI 2021-2022 1

Table des matières

1 Série 1 ................................................................................................................................. 4
1.1 Objectifs....................................................................................................................... 4
1.2 Exercice 1 .................................................................................................................... 4
1.3 Exercice 2 .................................................................................................................... 4
1.4 Exercice 3 .................................................................................................................... 4
1.5 Exercice 4 .................................................................................................................... 5
2 Série 2 ................................................................................................................................. 5
2.1 Objectifs....................................................................................................................... 5
2.2 Exercice 1 .................................................................................................................... 5
2.3 Exercice 2 .................................................................................................................... 5
2.4 Exercice 3 .................................................................................................................... 5
2.5 Exercice 4 .................................................................................................................... 6
2.6 Exercice 5 .................................................................................................................... 6
2.7 Exercice 6 .................................................................................................................... 6
2.8 Exercice 7 .................................................................................................................... 6
2.9 Exercice 8 .................................................................................................................... 7
2.10 Exercice 9 ................................................................................................................. 7
2.11 Exercice 10 ............................................................................................................... 8
3 Série 3 ................................................................................................................................. 8
3.1 Objectifs....................................................................................................................... 8
3.2 Exercice 1 .................................................................................................................... 9
3.3 Exercice 2 .................................................................................................................. 10
4 Série 4 ............................................................................................................................... 11
4.1 Objectif ...................................................................................................................... 11
4.2 Exercice 1 .................................................................................................................. 11
4.3 Exercice 2 .................................................................................................................. 12
4.4 Exercice 3 .................................................................................................................. 13
4.5 Exercice 4 .................................................................................................................. 14
4.6 Exercice 5 .................................................................................................................. 15
5 Série 5 ............................................................................................................................... 15
5.1 Objectifs..................................................................................................................... 15
5.2 Exercice 1 .................................................................................................................. 15

5.3 Exercice 2 .................................................................................................................. 17

5.4 Exercice 3 .................................................................................................................. 19
5.5 Exercice 4 .................................................................................................................. 19
6 Série 6 ............................................................................................................................... 19
6.1 Objectifs..................................................................................................................... 19
6.2 Exercice 1 .................................................................................................................. 20
6.3 Exercice 2 .................................................................................................................. 21
6.4 Exercice 3 .................................................................................................................. 23
7 Série 7 ............................................................................................................................... 24
7.1 Objectifs..................................................................................................................... 24
7.2 Exercice 1 .................................................................................................................. 24
7.3 Exercice 2 .................................................................................................................. 24
7.4 Exercice 3 .................................................................................................................. 25
7.5 Exercice 4 .................................................................................................................. 25
7.6 Exercice 5 .................................................................................................................. 25
7.7 Exercice 6 .................................................................................................................. 26
7.8 Exercice 7 .................................................................................................................. 26
8 Série 8 ............................................................................................................................... 26
8.1 Objectifs..................................................................................................................... 26
8.2 Exercice 1 .................................................................................................................. 27
8.3 Exercice 2 .................................................................................................................. 27
8.4 Exercice 3 .................................................................................................................. 28
9 Série 9 ............................................................................................................................... 28
9.1 Exercice ..................................................................................................................... 28
10 Série 10 .......................................................................................................................... 29
10.1 Objectifs : ............................................................................................................... 29
10.2 Explorateur et Projet .............................................................................................. 29
10.3 Classe ..................................................................................................................... 32
10.4 Exercice 1 ............................................................................................................... 36
10.5 Exercice 2 ............................................................................................................... 36

1 Série 1
1.1 Objectifs
L’objectif de cette première série est de vous faire familiariser avec :
- La création des classes ;

- La déclaration des objets ;
- La manipulation des types de données ;
- Les traitements avec les expressions de conditions et des boucles
1.2 Exercice 1
Ecrivez une classe CalculSurface dont la méthode main affiche la surface d'un cercle dont le
rayon est mis au début dans une variable nommée rayon. Vous prendrez 3,14 comme valeur
de pi. Le format d'affichage sera du type "la surface du cercle de rayon 1.0 est 3.14".
1.3 Exercice 2
Ecrivez une classe Maximum qui contient une méthode main qui affecte la valeur de 3
variables de type int (le code contiendra des instructions du type "valeur1 = 20;) et
affiche la plus grande des 3 valeurs.
Exécutez cette méthode main avec différentes valeurs pour tester votre code.
1.4 Exercice 3
1. Copiez, corrigez, compilez et exécutez la classe suivante. Le programme suivant devrait
afficher 3 (ou 3.0).
public class Division {
public static void main(String args) {
int x, y;
x = 3;
y = 2;
double a = x / y;
double f = a * y;
System.out.println(f);
}
}
2. Idem pour la classe suivante (la classe doit afficher "1 + 1 = 2", 1800000000, c'est-à-dire
la valeur de e, puis 36.9) :
public class Calculs {
public static void main(String args) {
int a = 1;
int b = 1;
System.out.println(a + b + " = " + a + b);
int c = 900000000;
int e = c * 2;
System.out.println("e = " + e);
System.out.println(20.1 + 16.8); // Explications ?
}

Après avoir fait exécuter cette classe, remplacez 2 par 3 dans la multiplication qui donne la
valeur de e. Ne modifiez rien d'autre, compilez et exécutez. Quelle valeur est affichée pour e ?
Expliquez et modifiez le programme pour qu'il affiche la bonne valeur.
1.5 Exercice 4
1. Ecrivez une classe MaximumClavier qui contient une méthode main qui lit 3 valeurs
saisies au clavier par l'utilisateur et affiche la plus grande des 3 valeurs (Utilisez la classe
Console plus précisément sa fonction readInt()).
Exécutez cette méthode main avec différentes valeurs pour tester votre code.
2. Modifiez la classe MaximumClavier pour qu'elle affiche la position du nombre le plus

grand (1er, 2ème ou 3ème).
3. Ensuite, mettez dans x la plus grande valeur, puis la valeur suivante dans y et la plus petite
valeur dans z. Faites afficher les valeurs des 3 variables pour vérifier.
2 Série 2
2.1 Objectifs
L’objectif de ce TP est de vous faire travailler avec :
- Les méthodes (fonctions et procédures),

- Les paquetages et les structures de projets,
- Les tableaux et les exceptions
2.2 Exercice 1
1. Dans la méthode main d'une classe Fonctions, utilisez la classe java.lang.Math (cherchez
dans la documentation des API) pour faire afficher la racine carrée de 4 et cos(pi / 2). Un
petit étonnement pour cos(pi / 2) ?
2. Ajoutez une méthode aléatoire qui renvoie un nombre entier aléatoire compris entre 1 et n
(passé en paramètre).
3. A la suite de la méthode main faites afficher 100 nombres entiers aléatoires compris entre
1 et 10 (bornes comprises), et leur moyenne. De quel nombre la moyenne devrait-elle être
proche ?
2.3 Exercice 2
A la fin de la méthode main, appelez une méthode erreur dans laquelle vous vous arrangez
pour provoquer la levée d'une exception, par exemple en divisant par 0. Essayez de
comprendre le message d'erreur. Aide : si vous ne trouvez pas d'autres façons de lever une
exception, vous pouvez utiliser la méthode parseInt de la classe Integer.
2.4 Exercice 3
Ecrivez un programme Java qui affiche la valeur de n! pour un n entré au clavier par
l'utilisateur au début du programme.

Utilisez pour cela un appel récursif.
Testez pour n = 0, n = 1 et n = 3.
Lancez une exception de type IllegalArgumentException si le nombre passé en paramètre est

un nombre négatif.
2.5 Exercice 4
Reprenez l’exercice 4 de votre premier TP
1. Compilez et exécutez la classe MaximumClavier.
2. Mettez votre classe MaximumClavier dans un paquetage emi.GI.1A.<votre nom>.

Compilez et exécutez la classe MaximumClavier.
2.6 Exercice 5
À partir de cet exercice, toutes les classes devront être dans un paquetage et tous les fichiers
de vos exercices devront respecter la structure préconisée dans le cours (sous-répertoires src et
classes).
Ecrivez une classe MaximumTableau avec une méthode maxTableau qui renvoie le plus
grand entier d'un tableau d'entiers passé en paramètre. Testez dans la méthode main de la
classe.
2.7 Exercice 6
Ecrivez une classe Tableau qui contient les méthodes suivantes :
1. Méthode afficheTableau qui affiche tous les éléments d'un tableau passé en paramètre
(y compris les valeurs -1) en utilisant une boucle for "normale".
2. Méthode afficheTableau2 qui affiche tous les éléments d'un tableau (y compris les
valeurs -1) en utilisant une boucle "for-each".
3. Ecrivez une méthode afficheTableau3 qui affiche seulement les éléments non vides du
tableau.
2.8 Exercice 7
Ajoutez dans la classe Tableau les méthodes suivantes :
1. Méthode initialise qui initialise à -1 tous les éléments d'un tableau passé en paramètre
(toutes les cases du tableau sont vides).
2. Méthode ajouterElement qui ajoute un élément au tableau passé en paramètre. La

méthode ne fera rien si le tableau est déjà plein ; en ce cas elle renverra le
booléen false. Testez en utilisant afficheTableau de l'exercice précédent. Testez les
différents cas : ajout dans un tableau vide, en dernière position, dans un tableau plein.

3. Méthode remplir qui remplit complètement un tableau passé en paramètre avec une
valeur passée en paramètre, en utilisant les méthodes initialise et ajouterElement ; ça
n'est évidemment pas la meilleure façon d'écrire cette méthode !
4. Méthode testRemplir qui teste le bon fonctionnement de la méthode remplir (à vous de

trouver ce qu'elle doit faire). La méthode renverra true si tout s'est bien passé.
2.9 Exercice 8
Ajoutez dans la classe Tableau les méthodes suivantes :
1. Méthode rechercher qui recherche la position d'un entier dans un tableau. La méthode
renvoie -1 si l'élément n'est pas dans le tableau. La méthode renvoie 0 si l'entier est
dans le premier élément du tableau (même si le tableau contient d'autres éléments
égaux à l'entier recherché), et plus généralement, renvoie n - 1 si l'entier est dans la
position nième position du tableau.
2. Méthode rechercherTous qui renvoie toutes les positions du tableau qui contiennent
des éléments égaux à l'entier recherché dans le cas où il apparait plusieurs fois.
Attention à bien prendre en compte le cas où la valeur cherchée n'est pas dans le
tableau.
3. Méthode rechercherTableauTrie qui fait ce que fait la question 1 dans le cas où le

tableau est trié par ordre croissant (vous supposerez que c'est vrai, sans le vérifier).
4. Méthode croissant qui indique si le tableau est trié par ordre croissant.
5. Méthode rechercher2 qui utilise la méthode croissant pour choisir une des 2 méthodes
écrites précédemment pour effectuer la recherche du premier élément d'un tableau égal
à un entier donné (évidemment, on ne recherche pas ici les performances).
6. Méthode supprimer qui supprime un élément du tableau (le premier élément du

tableau égal à la valeur du paramètre de la méthode). Utilisez pour cela une des
méthodes de l'exercice précédent pour savoir l'indice de l'élément. Il faudra "tasser"
les éléments non vides si l'élément supprimé est au milieu des éléments non vides.
La méthode renvoie l'indice du tableau de l'élément qui a été supprimé. Elle renvoie -1
si l'élément n'a pas été trouvé.
7. Ecrivez une méthode supprimerTous qui supprimer tous les éléments du tableau égaux
à une valeur donnée. Utilisez pour cela la méthode rechercherTous.
2.10 Exercice 9
Ecrivez une classe TestArrays dont la méthode main
1. crée un tableau de 150 nombres entiers et le remplit avec des nombres tirés au hasard
entre 1 et 200 ;
2. affiche les valeurs du tableau en utilisant la classe Arrays ;

3. trie ce tableau par ordre croissant en utilisant la classe Arrays ;
4. affiche à nouveau les valeurs du tableau (pour vérifier le tri) ;
5. tire 20 nombres au hasard et indique s'ils appartiennent au tableau (et en ce cas, donne
la position dans le tableau) en utilisant la recherche dichotomique (voir classe Arrays).
2.11 Exercice 10
Ecrivez du code pour faire afficher les paramètres de la ligne de commande, un paramètre par
ligne.
Lorsque la ligne de commande ne contient aucun paramètre, est-ce que le tableau des
paramètres est null. S'il n'est pas null, quelle est sa longueur ?
Que se passe-t-il lorsqu'on affiche les valeurs de tous les éléments d'un tableau de longueur 0
avec une boucle for ?
Pour répondre à ces questions écrivez une classe Main qui contient une méthode main et
lancez l'exécution avec quelques paramètres ou aucun paramètre.
3 Série 3
3.1 Objectifs
Travailler avec les dates et les Chaines de caractères ainsi que les conversions de Types.

3.2 Exercice 1

3.3 Exercice 2
1. Ecrire un programme permettant de lire le nom et le prénom d'un étudiant, ensuite
transforme le nom en majuscule, la première lettre du prénom en majuscule et le reste
en minuscule.
2. Écrire un programme qui lit un mot au clavier et qui indique combien de fois sont
présentes chacune des voyelles a, e, i, o, u ou y, que celles-ci soient écrites en
majuscules ou en minuscules, comme dans cet exemple :
3. Écrire un programme qui lit un entier au clavier et qui l’affiche verticalement comme
dans cet exemple :

4. Écrire un programme qui récupère deux entiers sur la "ligne de commande" et

qui en affiche la somme en fenêtre console, comme dans cet exemple :
23 + 25 = 48
On vérifiera que les arguments fournis sont formés uniquement de chiffres;

dans le cas contraire, le programme s’interrompra.
4 Série 4
4.1 Objectif
L’objectif est d’explorer les aspects d’héritage et des interfaces.
4.2 Exercice 1
• Description
o La classe Etudiant hérite de la classe Personne.
o La classe Professeur hérite de la classe Employe et la classe Employe hérite
de la classe Personne.
o Un Etudiant est une Personne.
o Un Professeur est un Employe et un Employe est une Personne.
• Travail à faire
1. Développer les classes dans le package "ma.exelib.projet.classes".
o Chaque classe doit contenir un constructeur d'initialisation.
o Chaque classe doit redéfinir la méthode toString().
2. Développer une classe de Application dans le package "Heritage.test", dans cette
classe on demande de créer :
o deux étudiants.
o deux employés.
o deux professeurs.
o afficher les informations de chaque personne.

4.3 Exercice 2
1. Développer les classes ci-dessus en JAVA dans un package de votre choix.

NB : l’identifiant est auto incrément.
2. Redéfinir la méthode calculerSalaire () et la méthode affiche() dans la classe
Utilisateur.
Sachant que :
o Le manager aura une augmentation de 10% par rapport à son salaire normal,
o Le directeur général aura une augmentation de 40% par rapport à son salaire
normal.
3. Créer les profils :
o Chef de projet (CP),
o Manager (MN),
o Directeur de projet (DP),
o Directeur des ressources humaines (DRH),
o Directeur général (DG),
4. Créer des utilisateurs avec les différents profils métiers.
5. Afficher la liste des utilisateurs.
6. Filtrer la liste et afficher la liste des managers.

4.4 Exercice 3
Le directeur d'une entreprise de produits chimiques souhaite gérer les salaires et primes de ses
employés au moyen d'un programme Java.
Un employé est caractérisé par son nom, son prénom, son âge et sa date d'entrée en service
dans l'entreprise.
Dans un fichier Salaires.java, codez une classe abstraite Employe dotée des attributs
nécessaires, d'une méthode abstraite calculerSalaire (ce calcul dépendra en effet du type de
l'employé) et d'une méthode getNom retournant une chaine de caractère obtenue en
concaténant la chaine de caractères "L'employé " avec le prénom et le nom.
Dotez également votre classe d'un constructeur prenant en paramètre l'ensemble des attributs
nécessaires.
▪ Calcul du salaire
Le calcul du salaire mensuel dépend du type de l'employé. On distingue les types d'employés
suivants :
▪ Ceux affectés à la Vente. Leur salaire mensuel est le 20 % du chiffre d'affaire qu'ils
réalisent mensuellement, plus 400 Francs.
▪ Ceux affectés à la Représentation. Leur salaire mensuel est également le 20 %
du chiffre d'affaire qu'ils réalisent mensuellement, plus 800 Francs.
▪ Ceux affectés à la Production. Leur salaire vaut le nombre d'unités produites
mensuellement multipliées par 5.
▪ Ceux affectés à la Manutention. Leur salaire vaut leur nombre d'heures de travail
mensuel multipliées par 65 francs.
Codez dans votre fichier Salaires.java une hiérarchie de classes pour les employés en
respectant les conditions suivantes :
▪ La super-classe de la hiérarchie doit être la classe Employe.
▪ Les nouvelles classes doivent contenir les attributs qui leur sont spécifiques ainsi que
le codage approprié des méthodes calculerSalaire et getNom, en changeant le mot
"employé" par la catégorie correspondante.
▪ Chaque sous classe est dotée de constructeur prenant en argument l'ensemble des
attributs nécessaires.
▪ N'hésitez pas à introduire des classes intermédiaires pour éviter au maximum les
redondances d'attributs et de méthodes dans les sous-classes
▪ Employés à risques
Certains employés des secteurs production et manutention sont appelés à fabriquer et
manipuler des produits dangereux.
Après plusieurs négociations syndicales, ces derniers parviennent à obtenir une prime de
risque mensuelle.
Complétez votre programme Salaires.java en introduisant deux nouvelles sous-classes
d'employés. Ces sous-classes désigneront les employés des
secteurs production et manutention travaillant avec des produits dangereux.
Ajouter également à votre programme une interface pour les employés à risque permettant de
leur associer une prime mensuelle fixe de 200.-.
▪ Collection d'employés
Satisfait de la hiérarchie proposée, notre directeur souhaite maintenant l'exploiter pour
afficher le salaire de tous ses employés ainsi que le salaire moyen.
Ajoutez une classe Personnel contenant une "collection" d'employés. Il s'agira d'une collection
polymorphique d'Employe - regardez le cours si vous ne voyez pas de quoi il s'agit.
Définissez ensuite les méthodes suivantes à la classe Personnel :
▪ void ajouterEmploye(Employe)
qui ajoute un employé à la collection.

▪ void calculerSalaires()
qui affiche le salaire de chacun des employés de la collection.
▪ double salaireMoyen()
qui affiche le salaire moyen des employés de la collection.
Testez votre programme avec le main suivant :
class Salaires {
public static void main(String[] args) {
Personnel p = new Personnel();
p.ajouterEmploye(new Vendeur("Pierre", "Business", 45, "1995", 30000));
p.ajouterEmploye(new Representant("Léon", "Vendtout", 25, "2001", 20000));
p.ajouterEmploye(new Technicien("Yves", "Bosseur", 28, "1998", 1000));
p.ajouterEmploye(new Manutentionnaire("Jeanne", "Stocketout", 32, "1998", 45));
p.ajouterEmploye(new TechnARisque("Jean", "Flippe", 28, "2000", 1000));
p.ajouterEmploye(new ManutARisque("Al", "Abordage", 30, "2001", 45));
p.afficherSalaires();
System.out.println("Le salaire moyen dans l'entreprise est de " + p.salaireMoyen() + "
francs.");
}
}
Vous devriez obtenir quelque chose comme :
Le vendeur Pierre Business gagne 6400.0 francs.

Le représentant Léon Vendtout gagne 4800.0 francs.
Le technicien Yves Bosseur gagne 5000.0 francs.
Le manut. Jeanne Stocketout gagne 2925.0 francs.
Le technicien Jean Flippe gagne 5200.0 francs.
Le manut. Al Abordage gagne 3125.0 francs.
Le salaire moyen dans l'entreprise est de 4575.0 francs.
4.5 Exercice 4

4.6 Exercice 5
Créez une classe Liquide contenant seulement une méthode imprimer() qui affiche : ”je suis
un liquide”. Créez 2 classes dérivées de la classe Liquide, les classes Cafe et Lait, dont les
méthodes imprimer() affichent respectivement ”je suis un Café”, ”je suis du Lait”. Enfin vous
créerez une classe Tasse ayant un attribut l de la classe Liquide et une méthode
AjouterLiquide (Liquide li) et une méthode imprimer(). Testez l’utilisation : créer un tableau
de Tasses qui contient des différents liquides.
5 Série 5
5.1 Objectifs
L’objectif de ce TP est de vous faire travailler avec les interfaces et les classes abstraites.
Notez que :
• Une interface ne peut pas avoir de méthodes déclarées static (contrainte levée en Java8).
• Ne peut pas avoir de méthodes implémentées non plus (à la différence des classes
abstraites (contrainte levée en Java8, voir plus loin)
• final variable ne peut être modifiée.
• La réalisation (ou "implémentation") d'une interface, c'est définir des méthodes déclarées.
Elle doit être faite dans une classe séparée
• Une classe abstraite ne contient pas forcément des méthodes abstraites. Le fait qu'une
classe soit abstraite, implique qu'on ne peut pas en créer des instances. Il faut alors en
dériver des sous classes pour pouvoir instancier des objets et leur appliquer des méthodes.
• Mais une classe qui contient une méthode abstraite doit être déclarée abstraite. De même,
une sous-classe qui ne fournit pas l'implantation d'une méthode abstraite héritée (déclarée
dans une classe mère), doit être déclarée abstraite à son tour.
• Une classe abstraite permet de déclarer des membres non publics. Dans une interface,
toutes les méthodes doivent être publiques.
• Une classe peut implanter plusieurs interfaces mais ne peut avoir qu'une seule superclasse.
• Une interface n'appartient pas à la hiérarchie des classes issues de Object. Des classes sans
aucun rapport entre elles peuvent implanter la même interface. Alors que les classes qui
dérivent d'une même classe abstraite appartiennent à une même famille.
• On peut rajouter de nouvelles méthodes à une classe abstraite sans conséquences sur le
reste. Si on veut rajouter un profile de méthode à une interface, il faut la définir dans
toutes les classes qui réalisent l'interface. A moins d'en fournir une définition (par défaut)
dans l'interface elle-même (nouveau depuis Java8).
• Une interface peut faire extends de plusieurs autres interfaces (Le vérifier sur un
exemple interface C extends A , B {} ).
• A partir de Java 8, une interface peut fournir une implémentation par défaut pour une
méthode. Les classes qui réalisent l'interface peuvent redéfinir ou pas cette méthode. Si
elles ne la redéfinissent pas, c'est la méthode donnée dans l'interface qui sera invoquée par
les classes appelantes.
5.2 Exercice 1
Soit l’interface Pile qui représente une pile de caractères, défini par l'interface:

interface Pile {
final int MAX = 8;
public void empiler(char c);

// Empile un char
public char sommet();
// Retourne le sommet de la pile
public void depiler();
// Retire le sommet de la pile
public boolean vide();
// Teste si la pile est vide
public boolean pleine();
// Teste si la pile est pleine
};
On peut réaliser cette pile par une chaîne de caractères ou un tableau de caractères etc.
On peut utiliser StringBuilder pour mémoriser les caractères d'une pile. Déclarer par
exemple :
StringBuilder s = new StringBuilder(MAX);
On peut rajouter un caractère c à une chaîne s à l'endroit i par :
s.insert (i, c);
On peut consulter le i-ème caractère d'une chaîne s par :
c = s.charAt (i);
1. Utiliser ce qui précède pour créer une classe MaPile qui implémente une pile
avec StringBuilder.
Indication : empiler en rajoutant les caractères les uns derrière les autres, par exemple "b",
"br", "brd" etc.
2. Ecrire un programme test qui lit des caractères et les imprime en ordre inverse. Dernier
caractère lu est '#'.
On peut utiliser un tableau Java pour mémoriser les caractères d'une pile. Déclarer par
exemple :
char[] t = new char[MAX];
L'accès au éléments du tableau se fait normalement par indice, e.g. t[i].
3. Créer une classe TaPile qui implémente une pile avec un tableau cette fois-ci.
4. Reprendre le programme test précédent pour tester cette 2e implémentation.

5.3 Exercice 2
Soit l'interface:
interface MonApi {
// Interface avec des outils pour
// - imprimer un objet
// - convertir un objet vers format imprimable (cf. toString)
// - comparer deux objets (inférieur, égal, supérieur)
public void print();

// Affiche sur l'unité standard de sortie
public String convTexte();

// Formate un objet vers un texte imprimable
public int compare (object o);

// compare this avec o. retourne -1, 0 ou 1
}
1. Réaliser cette interface
2. Créer la classe Article.
Attributs : numéro, désignation, prixHT, quantite
Méthodes :
- double prixTTC(double TVA)

- void ajouter (int q)
- void retirer (int q)
- fonctions d’accès (getters et setters)
3. La classe Article doit implémenter l’interface MonApi. Rajouter à cette classe Article les
méthodes :
- Methode print()
public void print(){

System.out.println(convTexte());
}
- Methode convTexte()
public String convTexte() {

String s ="{" + numero + ","
+ designation + ","
+ prixHT + ","
+ qte + "}" ;
return s;
}
- Methode compare()
public int compare (Object o){

// on compare les numéros par exemple

Article w = (Article) o; // ! important
if (numero > w.numero)
return 1;
else if (numero < w.numero)
return -1;
else
return 0;
}
4. Tester la classe, par exemple : Article a = new Article(...);
System.out.println(article.convTexte());))
et aussi la méthode compare() avec des valeurs à vous.
5. Créer une classe Point (coordonnée x,y) avec des méthodes setX(), setY(), getX(), getY()
pour resp. affecter une coordonnée (x ou y) et accéder à sa valeur (x ou y). Mettre cette
classe dans un ficher Point.java et le compiler.
6. Faire un programme test qui crée un point p, lui affecte des coordonnées et imprime
ensuite ses coordonnées. Mettre ce programme dans un fichier TestPoint.java dans le
même répertoire.
7. Faire de même avec la classe Point et lui rajouter la programmation des méthodes selon le
même principe
public void print(){

System.out.printf("(%d, %d)\n",x,y);
}
NB. Pour un point de coordonnées (1, 2), la méthode convTexte() donne le format "{x:1,
y:2}"
8. Tester ensuite comme suit :
MonAPI point = new Point(1,2);

MonAPI article = new Article (2,"chemise",15.5, 45);
point.print();
article.print();
String s = point.convTexte();
String t = article.convTexte();
Commenter.
(Autre aspect du polymorphisme, non lié à l'héritage: deux objets indépendants
(point et article) déclarés néanmoins de même type (interface MonAPI ici), à qui on
applique donc les opérations de l'interface et qui les exécutent chacun à sa façon selon son
implémentation.)
9. Tester aussi avec la séquence suivante :
Point point = new Point(1,2);

Article article = new Article (2,"chemise",15.5, 45);
MonAPI [] p = {point, article};
for (int i=0; i<2; i++)
p[i].print();

10. Tester ensuite la séquence d'instructions
MonAPI point = new Point(1,2);

MonAPI article = new Article (2,"chemise",15.5, 45);
point = article; //
point.print(); // print de Article exécutée bien sûr!
Constater la différence entre point.print() de 3).
La chose à noter ici, c'est qu'on a deux objets (point et article) sans aucun lien conceptuel qui
sont "interchangeables" ici car de "même type".
11. Peut-on écrire point.compare(article); par exemple? Vérifier la compilation et l'exécution

de cette instruction. Discuter.
5.4 Exercice 3
1. Créer une classe abstraite Shape qui possède les attributs perimetre et surface, et les
méthodes abstraites calculerPerimetre() et calculerSurface().
2. Créer la classe Circle qui hérite de la classe Shape. Cette classe possède les attributs
rayon et centre (le centre est un point, réutiliser la classe Point de l’exercice
précédent). Définir les méthodes calculerPerimetre() et calculerSurface().
3. Créer la classe Rectangle qui hérite de la classe Shape et qui possèdent comme
attributs 4 points A, B, C et D. Ajouter les méthodes calculerLongueur() qui calcule la
distance entre A et B et calculerLargeur() qui calcule la distance entre A et C. au
niveau du constructeur, vérifier que les points constituent deux droites orthogonales
(utilisez les équations des droites) sinon assurez-vous d’attribuer des coordonnées à D
qui permettent de faire de l’objet un rectangle. Définir les méthodes
calculerPerimetre() et calculerSurface().
4. Créer la classe Carre qui hérite de la classe Rectangle. Au niveau du constructeur,
assurez-vous que la longueur et largeur sont égales.
5.5 Exercice 4
1. Créer une classe abstraite Animal qui possède les attributs : poids et couleur ; et les
méthodes abstraites depalcer() et crier().
2. Créer une classe abstraite AnimalDomestique. Ajouter un attribut dateNaissance et un
attribut vaccins de type tableau de dates. Ajouter une méthode getAge() qui renvoie
l’âge de l’animal en faisant soustraction entre la date d’aujourd’hui et la date de
naissance.
3. Créer une classe Chien qui hérite de la classe AnimalDomestique. La méthode
deplacer() affiche « je marche sur 4 pattes » et crier() affiche « j’aboie ».
4. Créer une classe Chat qui hérite de la classe AnimalDomestique. La méthode
deplacer() affiche « je marche sur 4 pattes » et crier() affiche « je miaule ».
6 Série 6
6.1 Objectifs
L’objectif de ce TP est de vous faire travailler avec les références et le clonage.

6.2 Exercice 1
1. Faites les tests et répondre aux questions suivantes
2. Tester la fonction equal
3. Tester le clonage

6.3 Exercice 2
Cet exercice est surtout une petite réflexion sur la notion de duplication ou clonage d’objets,
surtout quand il s’agit d’objets qui ont pour membres d’autres objets (ce qui est le cas de la
majorité).
Vous devez disposer d’une classe Point, même très simple (par exemple, celle du début de
l’exercice précédent). Assurez-vous que cette classe n’a pas de constructeur sans arguments.
A. Un rectangle est déterminé par la donnée de deux points, respectivement son angle
supérieur gauche et son angle inférieur droit. Définissez une classe Rectangle ayant deux

variables d’instance privées coinNO (pour « coin Nord-Ouest ») et coinSE (pour « coin Sud-
Est ») et, au moins, les méthodes suivantes :
• Rectangle(double x0, double y0, double x1, double y1), constructeur d’un rectangle
ayant (x0,y0) et (x1,y1) pour coins,
• String toString(), qui renvoie une expression du rectangle sous forme de texte,
comme "[(1.0,2.0);(3.0,4.0)]",
B. Faites le test suivant :
public static void main(String[] args) {
Rectangle r1, r2;
r1 = new Rectangle(1, 2, 3, 4);
r2 = r1;
System.out.println("r1: " + r1 + ", r2: " + r2);
r1.coinNO = new Point(0, 0);
r1.coinSE.homothetie(2);
Si on pensait que l’expression « r2 = r1; » affectait à r2 une duplication de r1, qu’est-ce que
l’exécution du code précédent démontre ?
C. Écrivez la première ligne de la classe Rectangle comme ceci
public class Rectangle implements Cloneable {
et l’en-tête de la fonction main comme ceci
public static void main(String[] args) throws CloneNotSupportedException {
Maintenant remplacez la ligne « r2 = r1; » par
r2 = (Rectangle) r1.clone();
Votre classe utilise donc maintenant la version prédéfinie de la méthode clone. Reexécutez le
test : qu’est-ce que vous constatez ?
D. Ajoutez à votre classe la méthode suivante (vous pouvez effacer ou non les déclarations
« implements » :

public Rectangle clone() {
return new Rectangle(coinNO.x(), coinNO.y(), coinSE.x(), coinSE.y());
et refaites le test. Que constatez-vous à présent ?
6.4 Exercice 3
Vous travaillez chez Bobard & Co., fabriquant exclusif du sirop Mirifik, un élixir issu de la
recherche spatiale qui rend jeune, beau et intelligent et qui empêche la chute des cheveux et
les tâches de transpiration. Dilué à différentes concentrations, le sirop Mirifik est
commercialisé dans diverses sortes de flacons.
On vous demande d’écrire une classe Flacon dont les instances représentent les flacons de
sirop Mirifik en stock. Cette classe comportera :
• des variables d’instance :
o private final float capacite – la capacité du flacon (en ml) ,
o private float volume – le volume de liquide (en ml) que le flacon contient à un
instant donné,
o private float concentration – la concentration de ce liquide, c.-à-d. le rapport

(volume sirop) / (volume sirop+eau),
o String etiquette – un texte libre « affiché » sur le flacon
• des méthodes :
o public Flacon(String etiquette, float capacite) – Construction d’un flacon

ayant la capacité donnée et portant l’étiquette indiquée. Initialement, le volume
est mis à zéro.
o public void verser(float volumeSirop, float volumeEau) – Ajout à un flacon

des volumes de sirop et d’eau indiqués.
La possibilité d’une telle opération doit être vérifiée et, en cas d’impossibilité,
on doit produire l’affichage d’un message et l’abandon du programme.
o public void transvaser(Flacon autreFlacon, float volume) – Ajout à un

flacon du volume indiqué du liquide extrait de l’autreFlacon indiqué.
La possibilité d’une telle opération doit être vérifiée et, en cas d’impossibilité,
on doit produire l’affichage d’un message et l’abandon du programme.
o public String toString() – Production d’une chaîne de caractères indiquant

l’étiquette, le volume et la concentration du contenu du flacon en question.
Écrivez également une méthode main pour tester toutes ces opérations.

Que pensez-vous des qualifieurs que nous avons appliqué aux variables d’instance ?
Pourquoi capacite a été qualifiée final ? Est-il intéressant de qualifier private le volume et
la concentration ?
N.B. Comme à l’exercice précédent, pour abandonner le programme vous pouvez appeler la
méthode System.exit(code).
7 Série 7
7.1 Objectifs
L’objectif de ce TP est de travailler avec les flux et les fichiers en Java.
7.2 Exercice 1
Écrire un programme permettant de créer séquentiellement un fichier binaire comportant pour
différentes personnes les informations suivantes : nom, prénom et année de naissance.
Le dialogue de saisie de l’information s’effectuera en fenêtre console comme dans cet exemple
:
Nom du fichier a creer : e:\repert

nom 1 : Carre
Prenom : Thibault
annee naissance : 1997
.....
nom 5 : Mitenne
Prenom : Thomas
annee naissance : 2001
nom 6 :
**** fin creation fichier ****
On proposera deux solutions :
1. Les informations relatives au nom et au prénom seront conservées dans le fichier sous la
forme d’une suite de 20 caractères (comportant d’éventuels espaces à la fin).
2. Ces mêmes informations seront conservées sous la forme d’une chaîne codée dans le format
UTF (Ce format (Unicode Text Format) permet de coder une chaîne sous forme d’une suite
d’octets en nombre variable (chaque caractère étant codé sur un à trois octets). La méthode
writeUTF de la classe DataOutputStream réalise cette transformation d’une chaîne en une suite
de caractères UTF) ; aucune contrainte ne portera sur leur longueur.
7.3 Exercice 2
Réaliser un programme permettant de consulter un fichier du type de celui créé par la
première solution à l’exercice 1.
1. Le programme doit permettre à L’utilisateur de saisir le nom de fichier que le

programme va ouvrir. On signalera par des messages d’erreurs si le fichier donné est
inexistant.

2. Par la suite le programme demande à l’utilisateur de saisir le numéro d’un

enregistrement que le programme va afficher avec le nom, le prénom et la date
naissance. On signalera par des messages d’erreurs si le numéro donné est négativ ou
supérieur à la taille du fichier.
7.4 Exercice 3
Écrire un programme qui liste en fenêtre console le contenu d’un fichier texte en numérotant
les lignes. On prévoira 4 caractères pour l’affichage du numéro de ligne. Les lignes de plus de
60 caractères seront affichées sur plusieurs lignes d’écran comme dans cet exemple :
Donnez le nom du fichier texte a lister : e:\book\essai.txt

1 Ceci est la premiere ligne d'un exemple de fichier texte
2 Il contient des lignes de chiffres de longueurs variables dont une de 59 caracteres, une de 60
caracteres et une de 61 caracteres
3 12345678901234567890
4 123456789012345678901234567890123456789012345678901234567890
5 12345678901234567890123456789012345678901234567890123456789
6 123456789012345678901234567890123456789012345678901234567890 1
7 1234567890123456789012345678901234567890
8 la ligne suivante est vide
9
10 les deux lignes suivantes sont egalement vides
11
12
13 Ceci est la derniere ligne du fichier
*** fin liste fichier ***
7.5 Exercice 4
Écrire un programme qui affiche le contenu d’un répertoire (dont le nom est fourni au
clavier), en précisant pour chaque nom s’il s’agit d’un sous-répertoire ou d’un fichier ; dans
ce dernier cas, il en fournira également la taille en octets.
Exemple :
nom du repertoire : e:\truc

Nom incorrect (inexistant ou non repertoire)
nom du repertoire : e:\book\exosjav
evbn.fm FICHIER 84992 octets
control.fm FICHIER 96256 octets
divers REPERTOIRE
menuac.fm FICHIER 112640 octets
classes REPERTOIRE
essai.txt FICHIER 5120 octets
7.6 Exercice 5
Ecrire un programme qui permet de compter le nombre d'occurrence d'un mot donné dans un
fichier donné. Le nom du fichier et le mot seront indiqués sur la ligne de commande.

7.7 Exercice 6
On s'intéresse à noter dans un fichier une suite de scores sous la forme d'une suite de lignes ;
chaque ligne contient un nom et un entier ; l'entier représente un score obtenu par la personne
dont le nom est indiqué. On aura par exemple :
irene 12
olivier 8
david 19
Il s'agit de réaliser un programme qui permette de prendre à partir de l'entrée standard des
lignes constituées d'un nom et d'un score pour actualiser le fichier.
• Si le nom n'existait pas, une nouvelle ligne est créée pour mettre ce nouveau nom et
son score.
• Si le nom existait déjà, le score est actualisé.
Dans une même exécution du programme, l'utilisateur pourra entrer successivement plusieurs
lignes comportant chacune nom et score. Il terminera en retournant une ligne blanche.
Après chaque ajout ou modification de score, le fichier sera actualisé et son contenu sera
affiché.
L'utilisateur indiquera sur la ligne de commande le nom du fichier utilisé. Si le fichier
n'existait pas, il serait alors créé.
On conseille de créer une classe, nommée par exemple Joueur contenant deux attributs : un
pour un nom (chaîne de caractères), un pour un score(entier) et d'écrire dans le fichier
directement les instances de Joueur, comme des Object(s) ; bien entendu, on lira alors dans le
fichier des Object(s). Dans ce cas, on ne pourra pas lire le fichier directement, visuellement,
en l'ouvrant.
7.8 Exercice 7
1. Reprendre l’exercice 1 de la série 4, et rendre la classe Personne sérialisable.
2. Ajouter la fonction equal(Object) dans la classe Etudiant.
3. Ecrire un programme principal permettant de déclarer un employé em, un étudiant e et
un professeur p.
4. Améliorer le programme pour permettre de lire le nom de 3 fichiers chacun pour la
sérialisation de l’étudiant, de l’employé et du professeur.
5. Déclarer 3 autres objets em1, e1 et p1 de types Employe, Etudiant et Professeur pour y
désérialiser les 3 objets précédemment sérialisés.
6. Modifier dans e. Resérialiser le et désérialiser le dans un autre objet e2, puis comparer
e1 avec e2.
8 Série 8
8.1 Objectifs
L’objectif de cette série est de travailler avec les collections et les itérateurs tout en explorant
le tri sur les collections.

8.2 Exercice 1
1. Quels résultats fournira ce programme :
import java.util.*;
public class Essai{
public static void main (String args[]){
LinkedList<Integer> liste = new LinkedList <Integer> () ;
liste.add (3) ; liste.add (5) ; nliste.add (3) ;
liste.add (12) ;nliste.add (3) ;
System.out.println (liste) ;
liste.remove (3) ; System.out.println (liste) ;
liste.remove (new Integer(3)) ; System.out.println (liste) ;
Iterator <Integer> it = liste.iterator () ;
while (it.hasNext()) if (it.next()==3) it.remove() ;
System.out.println (liste) ;
}
}
2. RappelonsOn dispose d’un objet tab déclaré ainsi :
ArrayList <Integer> tab ;

Écrire les instructions réalisant les actions suivantes sur les valeurs de tab :
• affichage dans l’ordre naturel (on proposera au moins 4 solutions) ;

• affichage dans l’ordre inverse (au moins 2 solutions) ;
• affichage des éléments de rang pair (0, 2, 4…) (au moins 2 solutions) ;
• mise à zéro des éléments de valeur négative (au moins 2 solutions).
8.3 Exercice 2
On dispose de la classe Cercle suivante :
class Cercle{
public Cercle (int x, int y, double rayon){
this.x = x ; this.y = y ; this.rayon = rayon ; }
public void affiche (){
System.out.println ("Coordonnees : " + x + ", " + y
+ " ; rayon : " + rayon) ;
}
public double getRayon () { return rayon ; }
public int getX () { return x ; }
private int x, y ;
double rayon ;
}
1. Écrire les instructions permettant de trier, sans modifier la classe Cercle, un tableau (de
type ArrayList) d’objets de type Cercle :
• suivant les valeurs croissantes de leur rayon ;
• suivant les valeurs croissantes de leur abscisse.

2. Modifier la classe Cercle, de manière à ce que l’appel (liste étant un objet de type
ArrayList<Cercle>) :
Collections.sort (liste) ;
3. Trier les éléments de liste, suivant les valeurs croissantes de leur rayon.
8.4 Exercice 3
Réaliser une classe nommée Index permettant de gérer un index d’ouvrage. Un tel index
associe une entrée (mot ou suite de mots) à un ou plusieurs numéros de page (contrairement à
ce qui se passe dans les index de la plupart des ouvrages, on ne prévoira pas d’entrées à
plusieurs niveaux).
La classe Index disposera, en plus d’un constructeur, des méthodes :
• ajouter pour introduire une nouvelle entrée, associée à un numéro de page ;
• liste pour afficher la liste de l’index, par ordre alphabétique des entrées, la liste des
numéros de page d’une même entrée étant triée par valeur croissante ; l’affichage
d’une entrée d’index se présentera sur une même ligne sous la forme :
Java : 12 25
On prendra bien soin de n’associer qu’une seule fois un même numéro de page à une entrée
donnée.
9 Série 9
9.1 Exercice
1. Ecrivez une application qui permet à l’utilisateur d’afficher soit un cercle soit un
rectangle de taille fixe. L’utilisateur va d’abord sélectionner « cercle » ou « rectangle »
en utilisant un JcomboBox. Le cercle ou rectangle sera affiché quand l’utilisateur
presse un bouton de la souris. Le cercle ou rectangle sera affiché à l’endroit où se
trouve le curseur au moment du click.
2. Modifiez votre application pour permettre l’utilisateur de choisir le diamètre de son
cercle ou la largeur et la hauteur de son rectangle. Utilisez un JtextField a cet effet. Si
l’utilisateur demande un cercle ou un rectangle qui dépasse la taille de la fenêtre,
l’avertir en ouvrant une boite de dialogue. Permettre aussi à l’utilisateur de choisir la
couleur de l’objet : bleu, rouge ou jaune.
3. Modifiez votre application pour permettre l’utilisateur de créer quelques cercles et
rectangles et de les déplacer. Pour choisir l’objet à déplacer l’utilisateur met le curseur
sur l’objet et presse un bouton de la souris. Il garde le bouton pressé pendant qu’il
déplace la souris. L’objet sera affiché à l’endroit ou se trouve le curseur au moment ou
l’utilisateur lâche le bouton. Notons qu’il faut stocker les objets (dans un ArrayList) au
moment où ils sont créés pour pouvoir les sectionner plus tard. 4. Ajoutez un bouton
pour rafraîchir l’image et un bouton pour tout effacer.

10 Série 10
10.1 Objectifs :
Au cours de ce TP, nous allons introduire l’outil de développement, nommé Eclipse, puis
comment se servir du terminal sur une machine Linux ou Mac, puis introduire Git, le système
de gestion des versions.
10.2 Explorateur et Projet

Lancez Eclipse à partir des menus de votre environnement Unix ou Windows.
Une fois la fenêtre d’Eclipse apparue, identifier le panneau nommé Explorateur de packages
représentés ci-dessous.
Faire un click droit à l’intérieur de l’Explorateur de packages. Dans le menu qui apparaît, voir
ci-dessous, emmener la souris sur Nouveau puis choisir Autre… lorsque le second menu
apparaît.

Une fenêtre apparaît, voir ci-dessous, qui vous demande de sélectionner un type de projet. En
effet, Eclipse est polyvalent et permet l’édition de différents types de projets dans différents
langages. Cliquer sur Projet Java puis sur le bouton Suivant.
Une nouvelle fenêtre apparaît, voir ci-dessous, qui vous demande d’entrer le nom du projet.
Ecrire tp01 dans le champ Nom du projet. Ne pas modifier les autres options. Cliquer sur le
bouton Terminer.

Le projet créé, tp01, apparaît dans le panneau Explorateur de packages, voir ci-dessous.
Cliquer sur le petit triangle (▶) à gauche du nom du projet. Le triangle se tourne vers le bas
(▼) et le contenu du projet est dévoilé, voir ci-dessous.

On voit apparaître le dossier src (abréviation de source) destiné à recevoir vos programmes
ainsi que le dossier Bibliothèque système JRE qui contient l’ensemble des bibliohèques que
Java met à votre disposition. En cliquant sur le triangle (▶)à gauche du dossier Bibliothèque
système JRE, on voit apparaître la liste de ces bibliothèques. Voir ci-dessous.
Ces bibiothèques sont des ensembles de programmes, les classes prédéfinies, que Java met à
votre disposition. Nous en étudirons certaines en cours. En cliquant sur le triangle (▼)à
gauche du dossier Bibliothèque système JRE, on referme ce dossier.
10.3 Classe
Nous allons créer une classe. Pour cela, click droit sur le dossier src. Un menu apparaît,
amener la souris sur Nouveau. Un sous-menu apparaît, amener la souris sur Classe et cliquer.

Une fenêtre apparaît. Voir ci-dessous.

Dans le champ Nom, écrire HelloWorld. Sélectionner la boîte (checkbox) devant public static
void main(String[] args). Cliquer sur le bouton Terminer.
Dans le panneau Explorateur de packages, on voit apparaître le fichier de la classe

HelloWorld.java. Et le panneau central d’édition contient à présent cette classe.
Dans cette classe, ce qui se situe entre /** et */ et ce qui se situe entre un // et la fin de la ligne
sont des zones dédiées à l’écriture de commentaires. Ces zones de commentaires ont été
générées par Eclipse. Une méthode telle que la méthode main est celle qui sera exécutée au

lancement du programme. Cette méthode main a été générée par Eclipse. Elle est vide. Dans
son corps, écrire l’instruction suivante :
System.out.println(“Hello World !”) ;
Vous obtenez :
Cette instruction a pour fonction d’écrire la chaîne de caractères Hello World ! dans ce que
l’on appelle la Console. Pour exécuter ce programme, cliquer sur le bouton rond vert avec un
triangle blanc à l’intérieur. Ce bouton se situe dans la barre de menu.
Eclipse compile alors votre programme. Cela se fait très rapidement. Puis il en lance
l’exécution. La méthode main de votre class HelloWorld est exécutée. Le panneau Console
apparaît en bas de votre fenêtre Eclipse. On y voir le résultat de l’instruction d’écriture.
L’exécution est aussitôt terminée.
Vous venez d’exécuter votre premier programme Java…

10.4 Exercice 1
Décomposez l'algorithme d'Euclide pour le cacul du PGCD selon le principe de la
programmation structurée (une seule structure à chaque décomposition).
Traduisez en Java (les 2 nombres du départ sont entrés au clavier). Testez.
10.5 Exercice 2
1. Ecrivez un programme Java qui affiche la valeur de n! pour un n entré au clavier par
l'utilisateur au début du programme.
Donnez 2 versions itératives (avec une répétition "tant que", puis "for").
Testez pour n = 0, n = 1 et n = 3.
2. Reprenez l’exercice mais utilisez la classe java.math.BigInteger pour représenter les

nombres entiers. Vous pourrez ainsi calculer n! pour les grands nombres.

TPs Java 2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TPs Java 2022

Transféré par

Droits d'auteur :

Formats disponibles

Ecole Mohammadia d'Ingénieurs Génie Informatique

Département Informatique 1ère Année

Asmae EL KASSIRI 2021-2022 1

Table des matières

Asmae EL KASSIRI 2021-2022 2

5.3 Exercice 2 .................................................................................................................. 17

Asmae EL KASSIRI 2021-2022 3

- La création des classes ;

Asmae EL KASSIRI 2021-2022 4

2. Modifiez la classe MaximumClavier pour qu'elle affiche la position du nombre le plus

- Les méthodes (fonctions et procédures),

Asmae EL KASSIRI 2021-2022 5

Utilisez pour cela un appel récursif.

Lancez une exception de type IllegalArgumentException si le nombre passé en paramètre est

1. Compilez et exécutez la classe MaximumClavier.

2. Mettez votre classe MaximumClavier dans un paquetage emi.GI.1A.<votre nom>.

2. Méthode ajouterElement qui ajoute un élément au tableau passé en paramètre. La

Asmae EL KASSIRI 2021-2022 6

4. Méthode testRemplir qui teste le bon fonctionnement de la méthode remplir (à vous de

3. Méthode rechercherTableauTrie qui fait ce que fait la question 1 dans le cas où le

6. Méthode supprimer qui supprime un élément du tableau (le premier élément du

2. affiche les valeurs du tableau en utilisant la classe Arrays ;

Asmae EL KASSIRI 2021-2022 7

3. trie ce tableau par ordre croissant en utilisant la classe Arrays ;

4. affiche à nouveau les valeurs du tableau (pour vérifier le tri) ;

Asmae EL KASSIRI 2021-2022 8

Asmae EL KASSIRI 2021-2022 9

Asmae EL KASSIRI 2021-2022 10

4. Écrire un programme qui récupère deux entiers sur la "ligne de commande" et

On vérifiera que les arguments fournis sont formés uniquement de chiffres;

Asmae EL KASSIRI 2021-2022 11

1. Développer les classes ci-dessus en JAVA dans un package de votre choix.

Asmae EL KASSIRI 2021-2022 12

Asmae EL KASSIRI 2021-2022 13

Le vendeur Pierre Business gagne 6400.0 francs.

Asmae EL KASSIRI 2021-2022 14

Asmae EL KASSIRI 2021-2022 15

public void empiler(char c);

StringBuilder s = new StringBuilder(MAX);

On peut rajouter un caractère c à une chaîne s à l'endroit i par :

s.insert (i, c);

On peut consulter le i-ème caractère d'une chaîne s par :

char[] t = new char[MAX];

L'accès au éléments du tableau se fait normalement par indice, e.g. t[i].

4. Reprendre le programme test précédent pour tester cette 2e implémentation.

Asmae EL KASSIRI 2021-2022 16

public void print();

public String convTexte();

public int compare (object o);

Attributs : numéro, désignation, prixHT, quantite

- double prixTTC(double TVA)

public void print(){

public String convTexte() {

public int compare (Object o){

Asmae EL KASSIRI 2021-2022 17

// on compare les numéros par exemple

public void print(){

8. Tester ensuite comme suit :

MonAPI point = new Point(1,2);

Point point = new Point(1,2);

Asmae EL KASSIRI 2021-2022 18

10. Tester ensuite la séquence d'instructions

MonAPI point = new Point(1,2);