Vous êtes sur la page 1sur 24

Exercices en Java

1-Introduction aux applications Java


Exercices

 Exercice 1: Bienvenue
 Exercice 2: Calculs
 Exercice 3: Multiple

Bienvenue
Ecrire un programme qui affiche à l'écran l'expression "Bonjour!".

Calculs
Ecrire un programme qui demande à l'utilisateur de saisir 3 nombres entiers (boîte de
dialogue).
Le programme doit ensuite afficher la somme, la moyenne et le produit de ces 3
nombres dans une boîte de message.
Le calcul de la moyenne doit donner un résultat entier.

Multiple
Ecrire un programme qui demande à l'utilisateur de saisir 2 nombres entiers (boîte de
dialogue).
Le programme doit ensuite afficher si le premier est multiple du second.

2-Introduction aux applets Java


Exercices

 Exercice 1: Cercle
 Exercice 2: Rectangle
 Exercice 3: Ovale

Cercle
Ecrire un applet qui demande à l'utilisateur de saisir le rayon d'un cercle (en virgule
flottante).
L'applet doit ensuite afficher le diamètre du cercle(2 x R), la circonférence(2 x π x R)
du cercle et l'aire du cercle(π x R x R).
Vous pouvez utiliser la constante Math.PI définie dans le package java.lang.

Rectangle
Ecrire un applet qui demande à l'utilisateur de saisir les 4 arguments de la méthode
drawRect.
L'applet doit ensuite afficher un rectangle avec les 4 valeurs entrées.
Méthode de la classe Graphics : drawRect(int x, int y, int width, int height).

Ovale
Ecrire un applet qui affiche plusieurs ovales de tailles et de formes différentes.
Méthode de la classe Graphics : drawOval(int x, int y, int width, int height).

3-Structures de contrôle : partie 1


Exercices

 Exercice 1: Gestion de clients


 Exercice 2: Maximum
 Exercice 3: Palindrome
 Exercice 4: Cryptage
 Exercice 5: Décryptage

Gestion de clients
Ecrire une application qui vérifie si un client (d'un magasin) a dépassé sa limite de
crédit sur son compte débiteur. Pour chaque client, vous avez les données suivantes :
- le numéro de compte;
- le solde au début du mois;
- le total des articles portés en compte de ce client ce mois-ci;
- le total de tous les crédits appliqués au compte de ce client ce mois-ci;
- la limite de crédit autorisée.
L'utilisateur doit pouvoir saisir chaque donnée sous forme d'entiers dans des boîtes de
dialogue d'entrée, calculer le nouveau solde (solde début - débits + crédits), afficher le
nouveau solde et déterminer si le nouveau solde dépasse la limite de crédit du client
(dans ce cas, il faut afficher le message "Limite de crédit dépassée" ).

Maximum
Ecrire une application qui demande une suite de 10 nombres à un seul chiffre (sous la
forme de caractères) puis détermine et affiche le plus grand de ces nombres.
Astuce : utilisez 3 variables :
- compteur : qui compte jusqu'à 10;
- nombre : le chiffre courant;
- plusGrand : le plus grand nombre connu jusqu'ici.

Palindrome
Un palindrome est un nombre, un mot ou une phrase qui se lit de façon identique dans
un sens et dans l'autre.
Exemple de nombres qui sont des palindromes : 45654, 77777, 11511.
Ecrivez une application qui demande un entier de 5 chiffres et détermine si c'est un
palindrome. Si le nombre ne comporte pas 5 chiffres affichez dans une boîte de
message une erreur. Si l'utilisateur annule la boite de message, permettez- lui d'entrer
une nouvelle valeur.

Cryptage
Ecrire un programme qui crypte les données introduites par l'utilisateur dans une boîte
de dialogue d'entrée. Les données sont sous forme d'entiers de 4 chiffres.
Algorithme de cryptage : remplacer chaque chiffre par (la somme de ce chiffre et de
7) modulo 10; ensuite il faut permuter le premier chiffre et le troisième ainsi que le
deuxième et le quatrième.
Affichez le résultat dans une boîte de dialogue.

Décryptage
Ecrire un programme qui décrypte les données introduites par l'utilisateur dans une
boîte de dialogue d'entrée. Les données sont sous forme d'entiers de 4 chiffres.
Algorithme de cryptage : remplacer chaque chiffre par (la somme de ce chiffre et de
7) modulo 10; ensuite il faut permuter le premier chiffre et le troisième ainsi que le
deuxième et le quatrième. A vous de trouver l'algorithme de décryptage...
Affichez le résultat dans une boîte de dialogue.

4-Structures de contrôle : partie 2


Exercices

 Exercice 1: Produit de nombres


 Exercice 2: Produit de nombres (2)
 Exercice 3: Vente d'articles
 Exercice 4: Pythagore

Produit de nombres
Ecrivez une application qui calcule le produit des entiers impairs de 1 à 15 et affiche
ensuite le résultat dans une boîte de dialogue.
Utilisez une structure de contrôle for.

Produit de nombres (2)


Ecrivez une application qui calcule le produit des entiers impairs de 1 à 15 et affiche
ensuite le résultat dans une boîte de dialogue.
Utilisez une structure de contrôle while.

Vente d'articles
Une entreprise de vente par correspondance vend 5 produits dont les prix sont les
suivants :
- produit numéro 1 : 2.67€,
- produit numéro 2 : 9.65€,
- produit numéro 3 : 3.78€,
- produit numéro 4 : 5.26€,
- produit numéro 5 : 7.21€,
Ecrivez une application qui lise une suite de paires de nombres (numéro du produit &
quantité vendue dans la journée). Il faut utiliser une structure de contrôle switch pour
déterminer le prix d'un produit. Il faut ensuite calculer et afficher le détail des produits
vendus en une semaine. Pour la saisie des données, il faut utiliser un JTextField ; une
boucle contrôlée par sentinelle permet d'afficher le résultat et d'arrêter le programme.

Pythagore
Un triangle droit est un triangle dont la somme des carrés de deux côtés est égale au
carré de l'hypoténuse (Pythagore).
Ecrire une application qui trouve tous les triangles droits dont les côtés sont tous
inférieurs à 500. Pour faire cela, utilisez une boucle for imbriquée sur trois niveaux
afin de tester toutes les possibilités. C'est ce qu'on appelle une méthode de calcul par
"force brute".

5-Méthodes
Exercices

 Exercice 1: Nombre parfait


 Exercice 2: Nombre premier
 Exercice 3: PGCD
 Exercice 4: PGCD 2
 Exercice 5: Programme d'éducation
 Exercice 6: Deviner un nombre
 Exercice 7: Puissance
 Exercice 8: Tours de Hanoï
Nombre parfait
Un nombre entier est parfait si ses facteurs y compris 1 mais hormis lui- même
s'additionnent pour former le nombre.
Exemple 6 est un nombre parfait (1 + 2 + 3).
Ecrivez une méthode qui détermine si son paramètre nombre est parfait. Utilisez cette
méthode dans un applet qui affiche tous les nombres parfaits entre 1 et 1000. Affichez
aussi les facteurs de chacun de ses nombres pour vérifier.

Nombre premier
Un nombre entier est premier s'il n'est divisible que par 1 et lui- même.
Exemple : 2, 7, 13 sont des nombres premiers alors que 4, 9, 12 n'en sont pas.
Ecrivez une méthode qui détermine si un nombre est premier. Insérez cette méthode
dans un applet pour trouver tous les nombres premiers entre 1 et 1000.

PGCD
Le plus grand diviseur commun (PGCD) de deux nombres entiers est le plus grand
entier qui puisse diviser les deux nombres.
Ecrivez une méthode non récursive qui renvoie le PGCD de deux nombres passés en
paramètres. Utilisez cette méthode dans un applet qui demande les deux valeurs à
l'utilisateur et affiche le résultat dans la barre d'état.

PGCD 2
Le plus grand diviseur commun (PGCD) de deux nombres entiers est le plus grand
entier qui puisse diviser les deux nombres.
Ecrivez une méthode récursive qui renvoie le PGCD de deux nombres passés en
paramètres. Utilisez cette méthode dans un applet qui demande les deux valeurs à
l'utilisateur et affiche le résultat dans la barre d'état.

Programme d'éducation
Construisez un programme qui aide les étudiants de niveau élémentaire à apprendre
l'addition, la soustraction, la multiplication et la division.
L'étudiant doit pouvoir choisir entre 5 types de problèmes arithmétiques :
- 1 : addition
- 2 : soustraction
- 3 : multiplication
- 4 : division
- 5 : tous types
L'étudiant doit ensuite pouvoir sélectionner le niveau de difficulté :
- 1 : nombres à un seul chiffre.
- 2 : nombres à deux chiffres.
- 3 : nombres à 3 chiffres.
Utilisez Math.random pour générer aléatoirement des nombres.
Le programme affiche ensuite la question dans la barre d'état. Exemple : Combien fait
27 + 35? L'étudiant entre sa réponse dans un JTextFie ld.
Si la réponse est correcte un des messages suivants est dessinée sur l'applet :
- C'est très bien!
- Excellent!
- Tu fais du beau travail!
- Bonne réponse, continue
Et une nouvelle question est posée.
Si la réponse est incorrecte un des messages suivants est dessinée sur l'applet :
- Désolé, essaie encore.
- Mauvaise réponse. Essaie une autre fois.
- Non, essaie à nouveau.
Et la même question est reposée.
Pour déterminer la phrase qui sera affichée utilisez un nombre aléatoire entre 1 et 4.
Utilisez ensuite une structure switch pour afficher les messages.
Le programme doit compter le nombre de réponses correctes et incorrectes entrées par
l'étudiant. Au bout de 10 réponses, calculez le taux de réponses correctes. Si celui-ci
est inférieur à 75%, affichez le message "SVP, Demande à ton professeur de t'aider".
Un nouvelle session doit ensuite démarrer.

Deviner un nombre
Ecrivez un applet qui demande à l'utilisateur de deviner un nombre entier (choisi
aléatoirement) entre 1 et 1000. L'applet affiche "Devinez le nombre que j'ai choisi
entre 1 et 1000 : ". Un JTextField en dessous permet à l'utilisateur de rentrer un
nombre et de valider avec la touche entrée. Si la réponse est incorrecte le programme
affiche "Trop grand, essayez encore!" ou "Trop petit, essaye z encore" dans la barre
d'état et vide le JTextField. Lorsque la réponse est correcte affichez "Félicitation, vous
avez deviné le nombre!". Comptez le nombre d'essais du joueur. Quand le joueur a
trouvé le nombre, si le nombre de tentatives est inférieur à 10 affichez "Soit vous
connaissez le secret, soit vous êtes chanceux!". Si le nombre de tentatives est égal à
10 affichez "D'accord, vous connaissez le secret!". Sinon, affichez "Vous pouvez
certainement faire mieux!".

Puissance
Ecrivez une méthode récursive puissance(bas, exposant) qui renvoie base à la
puissance exposant.
Exemple : puissance(5, 3) = 5 * 5 * 5.
Intégrez cette méthode à un applet qui permette à l'utilisateur d'entrer la base et
l'exposant.

Tours de Hanoï
Les tours de Hanoï sont composées de trois piquets. Au départ, la pile contient un
certain nombre de disques sur le premier piquet empilés du plus grand au plus petit,
de bas en haut. Le but est de déplacer tous les disques du premier piquet au troisième
piquet sans que jamais un disque plus grand ne se retrouve au dessus d'un disque plus
petit. Le deuxième piquet permet d'empiler temporairement des disques.
L'algorithme récursif permettant de résoudre ce problème est le suivant :
1) Déplacer n-1 disques du premier piquet au deuxième piquet en utilisant le troisième
piquet comme piquet d'empilement temporaire.
2) Déplacer le dernier disque du premier piquet au troisième piquet. (le plus grand)
3) Déplacer n-1 disques du deuxième piquet au troisième piquet en utilisant le premier
piquet comme piquet d'empilement temporaire.
Créez un applet résolvant ce problème. Le nombre de disques étant saisi par
l'intermédiaire d'un JTextField. La méthode tour à écrire prend 4 paramètres : le
nombre de disques, le piquet où sont placés les disques au départ, le piquet servant
d'empilement temporaire et le piquet sur lequel doivent être les disques à la fin.
Ainsi le programme doit afficher les étapes de déplacement des disques d'un piquet à
un autre dans un JTextArea avec défilement.
Exemple avec un nombre de disque égal à 3 :
1 -> 3
1 -> 2
3 -> 2
1 -> 3
2 -> 1
2 -> 3
1 -> 3

5-Tableaux
Exercices

 Exercice 1: Tri Bulle


 Exercice 2: Jet de dés
 Exercice 3: Tortue Graphique
 Exercice 4: Crible d'Eratosthene
 Exercice 5: Tri Par Sélection
 Exercice 6: Recherche binaire
 Exercice 7: Parcours de labyrinthe

Tri Bulle
Le tri de données est un problème qui revient souvent. Le tri à bulle est un tri simple
qui n'est pas fait pour de grands tableaux. Ecrivez l'algorithme du tri à bulle. (Cet
agorithme consiste à comparer les différentes valeurs adjacentes d'un tableau et à les
échanger si besoin est. A chaque passage du tableau, un élément supplémentaire est
trié. Le nombre de passages nécessaires pour trier le tableau dans son intégralité est
donc de la taille du tableau moins un.)
Améliorez le ensuite sachant qu'à chaque passage supplémentaire une valeur de plus
est triée à la fin du tableau. Ainsi à chaque passage le nombre de comparaisons
nécessaires diminue de un.
Il est possible que le tableau soit trié avant que tous les passages du tableau ne soient
efectuées. La deuxième amélioration consiste donc à vérifier que si aucune
permutation n'a été faite, d'arrêter l'algorithme de tri.

Jet de dés
Ecrivez un applet qui simule grâce à des nombres aléatoires un lancer de deux dés. Il
existe 36 combinaisons et la somme des deux dés est comprise entre 2 et 12 avec
certaines plus fréquentes que d'autres. Simulez 36000 lancers et stockez la fréquence
de chaque somme dans un tableau. Affichez ensuite les résultats dans une zone de
texte et vérifiez que les fréquences sont correctes.
Ajoutez aussi un bouton afin de pouvoir effectuer de nouvelles séries de lancers de
dés.

Fréquence des possibilités:

 2: 1
 3: 2
 4: 3
 5: 4
 6: 5
 7: 6
 8: 5
 9: 4
 10: 3
 11: 2
 12: 1

Tortue Graphique
Le langage Logo est connu pour le concept de la tortue graphique. Elle permet de
dessiner sur une feuille. La tortue a deux états : relevée et descendue.
Lorsque celle ci est relevé, elle peut se déplacer librement et quand elle est descendue,
elle laisse une trace de ses mouvements.
Ecrivez un applet avec les fonctionnalités suivantes.
La feuille de dessin est représentée par un tableau de 20 par 20. La position de la
tortue et de son état sont conservées dans des variables. Au départ la tortue est sur la
case 0,0 et relevée. Les commandes de déplacement de la tortue sont stockées dans un
tableau. La liste des commandes est:

 1 : Relever la tortue,
 2 : Abaisser la tortue,
 3 : Tourner vers la droite,
 4 : Tourner vers la gauche,
 5,n : Avancer de n cases,
 6 : Afficher la feuille de dessin.

Quand la tortue fait une trace sur une case, la valeur de la case dans le tableau est
ajustée à 1. Pour l'affichage de la feuille, utilisez des astérisques ( '* ' ) et des points (
'. ' ) à police fixe (monospace) dans un
JTextArea.
Voici un exemple de programme simple:
5, 3, 3, 5, 8, 2, 5, 8, 4, 5, 8, 4, 5, 8, 4, 5, 8, 1, 3, 5, 5, 3, 5, 5,
2, 5, 8, 3, 5, 8, 3, 5, 8, 3, 5, 8, 1
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . * * * * * * * * * . . .
. . . . . . . . * . . . . . . . * . . .
. . . . . . . . * . . . . . . . * . . .
. . . . . . . . * . . . . . . . * . . .
. . . . . . . . * . . . . . . . * . . .
. . . * * * * * * * * * . . . . * . . .
. . . * . . . . * . . * . . . . * . . .
. . . * . . . . * . . * . . . . * . . .
. . . * . . . . * * * * * * * * * . . .
. . . * . . . . . . . * . . . . . . . .
. . . * . . . . . . . * . . . . . . . .
. . . * . . . . . . . * . . . . . . . .
. . . * . . . . . . . * . . . . . . . .
. . . * * * * * * * * * . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .

Crible d'Eratosthene
Le crible d'Eratosthène permet de trouver les nombres premiers. Un nombre premier
est un entier naturel strictement supérieur à 1 qui n'admet que deux diviseurs distincts
: 1 et lui- même. Son fonctionnement est le suivant:

- Utilisez un tableau de booléens où les indices correspondent aux nombres. Une


valeur à true indique que c'est un nombre premier, à false que non.

- Parcourez ce tableau en commançant à l'indice 2. Si l'indice courant est à true alors


mettez à false tous les éléments à true et multiple de l'indice.

Ecrivez un programme qui affiche tous les nombres premiers entre 1 et 1000.

Tri Par Sélection


Le tri par sélection recherche l'élément le plus petit du tableau et l'échange avec le
premier élément. Ensuite, on recommence cette opération avec le sous tableau
commençant par le deuxième élément. Le tableau est entièrement trié lorsque le sous
tableau ne contient plus qu'un seul sous élément.
Ecrivez un tel algorithme.

Recherche binaire
La recherche binaire fonctionne sur un tableau trié. L'algorithme compare à la clé
recherchée la valeur de l'élément au milieu du tableau. Si les deux valeurs sont égales
alors on renvoie l'indice sinon on continue la recherche avec la moitié du tableau
correspondant au résultat de la comparaison des deux valeurs. La recherche continue
jusqu'à ce que l'on trouve l'élément ou jusqu'à ce que le sous tableau ne contienne plus
qu'un seul élément différent de la clé, indiquant que celle-ci n'est pas dans le tableau.
Ecrivez un tel programme.

Parcours de labyrinthe
L'algorithme le plus simple qui permet de trouver la sortie d'un labyrinthe (si elle
existe), est de garder toujours sa main droite le long du mur en suivant les
changements de direction avec cette même main. Evidemment ce n'est certainement
pas le plus court... mais on trouve la sortie ainsi.
Ecrivez une méthode récursive qui implémente cet algorithme. Utilisez aussi un
JTextArea pour afficher une représentation du labyrinthe et ajoutez un bouton
permettant de suivre étape par étape le parcours dans le labyrinthe.
# # # # # # # # # # # #
# . . . # . . . . . . #
. . # . # . # # # # . #
# # # . # . . . . # . #
# . . . . # # # . # . .
# # # # . # . # . # . #
# . . # . # . # . # . #
# # . # . # . # . # . #
# . . . . . . . . # . #
# # # # # # . # # # . #
# . . . . . . # . . . #
# # # # # # # # # # # #

6-Programmation basée sur les objets


Exercices

 Exercice 1: Livre
 Exercice 2: Personne
 Exercice 3: Temps
 Exercice 4: Complexe
 Exercice 5: Rationnel
 Exercice 6: Rectangle
 Exercice 7: Point
Livre
Ecrivez une classe Livre avec les attributs suivants:

 titre : Le titre du livre,


 auteur: L'auteur du livre,
 prix: Le prix du livre,
 annee: L'année du livre.

La classe Livre doit disposer des constructeurs suivants:

 Livre(),
 Livre(titre),
 Livre(titre, auteur),
 Livre(titre, auteur, prix),
 Livre(titre, auteur, prix, annee),
 Livre(Livre).

La classe Livre doit contenir des accesseurs et mutateurs pour les différents attributs.
Elle doit aussi contenir une méthode toString() donnant une représentation de la classe
Livre.
Ecrivez aussi une classe de testLivre afin de tester la classe Livre.

Personne
Ecrivez une classe Personne avec les attributs suivants:

 nom: Le nom de famille de la personne,


 prenom: Le prénom de la personne,
 age: L'âge de la personne compris entre 0 et 130 ans,
 sexe: Masculin ou Féminin.

La classe Personne doit disposer des constructeurs suivants:

 Personne(): constructeur par défaut,


 Personne(nom, prenom),
 Personne(nom, prenom, age),
 Personne(nom, prenom, age, sexe),
 Personne(Personne).

La classe Personne doit contenir des accesseurs et mutateurs pour les différents
attributs. Elle doit aussi contenir une méthode toString() donnant une représentation
de la classe Personne.
Ecrivez aussi une classe de testPersonne afin de tester la classe Personne.

Temps
Ecrivez une classe Temps avec les attributs suivants:

 heures: De 0 à 23,
 minutes: De 0 à 59,
 secondes: De 0 à 59.

La classe Temps doit disposer des constructeurs suivants:

 Temps(): constructeur par défaut,


 Temps(heures),
 Temps(heures, minutes),
 Temps(heures, minutes, secondes),
 Temps(Temps).

La classe Temps doit contenir des accesseurs et mutateurs pour les différents attributs.
Elle doit aussi contenir les méthodes:

 ajouterHeures(heures),
 ajouterMinutes(minutes),
 ajouterSecondes(secondes),
 toString() donnant une représentation de la classe Temps.

Ecrivez aussi une classe de testTemps afin de tester la classe Temps.

Complexe
Ecrivez une classe Complexe représentant des nombres complexes. Un nombre
complexe comporte une partie réelle et une partie imaginaire (partieReelle +
partieImaginaire * i avec i = racine(-1)). La classe a les attributs suivants:

 partieReelle: La partie réelle du nombre,


 partieImaginaire : La partie imaginaire du nombre.

La classe Complexe doit disposer des constructeurs suivants:

 Complexe(): constructeur par défaut,


 Complexe(partieReelle, partieImaginaire),
 Complexe(Complexe).
La classe Temps doit contenir des accesseurs et mutateurs pour les
différents attributs. Elle doit aussi contenir les méthodes:

 ajouter(Complexe),
 soustraire(Complexe),
 toString() donnant une représentation d'un nombre complexe (a+b*i).

Ecrivez aussi une classe testComplexe afin de tester la classe Complexe.

Rationnel
Ecrivez une classe Rationnel qui définit les nombres rationnels. Les fractions
doivent être stockées de manière irréductible. La classe a les attributs suivants:

 numerateur,
 denominateur.

La classe Rationnel doit disposer des constructeurs suivants:

 Rationnel(): constructeur par défaut,


 Rationnel(numerateur, denominateur),
 Rationnel(Rationnel).

La classe Rationnel doit contenir des accesseurs et mutateurs pour les


différents attributs. Elle doit aussi contenir les méthodes:

 ajouter(Rationnel),
 soustraire(Rationnel),
 multiplier(Rationnel),
 diviser(Rationnel),
 evaluer(): renvoie le résultat sous la forme d'un nombre réel,
 toString(): donne une représentation du rationnel (a/b).

Ecrivez aussi une classe testRationnel afin de tester la classe Rationnel.

Rectangle
Ecrivez une classe Rectangle avec les attributs suivants:

 longueur,
 largeur.
La classe Rectangle doit disposer des constructeurs suivants:

 Rectangle(): constructeur par défaut,


 Rectangle(longueur, largeur),
 Rectangle(Rectangle).

La classe Rectangle doit contenir des accesseurs et mutateurs (qui vérifient que les
valeurs sont positives) pour les différents attributs. Elle doit aussi contenir les
méthodes:

 perimetre : Le périmètre est égal à 2 * (longueur + largeur),


 aire: L'aire est égale à longueur * largeur,
 isCarre : vérifie si le rectangle est un carré,
 toString: donne une représentation d'un rectangle.

Ecrivez aussi une classe testRectangle afin de tester la classe Rectangle.

Point
Ecrivez une classe Point avec les attributs suivants:

 x: abscisse du point,
 y: ordonnée du point.

La classe Point doit disposer des constructeurs suivants:

 Point(): constructeur par défaut


 Point(x, y),
 Point(Point).

La classe Rectangle doit contenir des accesseurs et mutateurs pour les différents
attributs. Elle doit aussi contenir les méthodes:

 distance(x, y),
 distance(Point),
 distance(x1, y1, x2, y2): version statique,
 deplace r(x, y),
 translate r(dx, dy),
 toString(): donne une représentation d'un point.

Ecrivez aussi une classe testPoint afin de tester la classe Point.


7-Programmation orientée objet
Exercices

 Exercice 1: Parallélogramme
 Exercice 2: Bâtiment
 Exercice 3: Figure
 Exercice 4: Employé
 Exercice 5: Forme
 Exercice 7: Evénement
 Exercice 6: GeoVecteur

Parallélogramme
Ecrivez une classe Point avec les attributs suivants:

 x: L'abscisse du point,
 y: L'ordonnée du point.

La classe Point doit disposer des constructeurs suivants:

 Point(),
 Point(x, y).

La classe Point doit contenir les accesseurs et mutateurs et aussi une méthode
toString() donnant une représentation du Point.

Ecrivez une classe Rectangle héritant de Point avec les attributs suivants:

 longueur: La longueur du rectangle,


 largeur: La largeur du rectangle.

La classe Rectangle doit disposer des constructeurs suivants:

 Rectangle(),
 Point(x, y, longueur, largeur).

La classe Rectangle doit contenir des accesseurs et mutateurs et aussi les méthodes
suivantes:

 aire(): Donne l'aire du rectangle,


 toString(): Donne une représentation du Rectangle (surcharge).
Ecrivez une classe Parallélogramme héritant de Rectangle avec le s attributs suivants:

 hauteur: La hauteur du parallélogramme.

La classe Parallélogramme doit disposer des constructeurs suivants:

 Parallelogramme (),
 Parallelogramme (x, y, longueur, largeur, hauteur).

La classe Parallélogramme doit contenir des accesseurs et mutateurs et aussi les les
méthodes suivantes:

 aire(): Donne l'aire du parallélogramme (surcharge),


 volume(): Donne le volume du parallélogramme,
 toString(): Donne une représentation du Parallélogramme (surcharge).

Ecrivez aussi une classe de testParallelogramme afin de tester les classes.

Bâtiment
Ecrivez une classe Bâtiment avec les attributs suivants:

 adresse.

La classe Bâtiment doit disposer des constructeurs suivants:

 Batiment(),
 Batiment(adresse).

La classe Bâtiment doit contenir des accesseurs et mutateurs pour les différents
attributs. La classe Bâtiment doit contenir une méthode toString() donnant une
représentation du Bâtiment.

Ecrivez une classe Maison héritant de Bâtiment avec les attributs suivants:

 nbPieces: Le nombre de pièces de la maison.

La classe Maison doit disposer des constructeurs suivants:


 Maison(),
 Maison(adresse, nbPieces).

La classe Maison doit contenir des accesseurs et mutateurs pour les différents
attributs. La classe Maison doit contenir une méthode toString() do nnant une
représentation de la Maison.

Ecrivez une classe Immeuble héritant de Bâtiment avec les attributs suivants:

 nbAppart: Le nombre d'appartements de l'immeuble.

La classe Immeuble doit disposer des constructeurs suivants:

 Immeuble(),
 Immeuble(adresse, nbAppart).

La classe Immeuble doit contenir des accesseurs et mutateurs pour les différents
attributs. La classe Immeuble doit contenir une méthode toString() donnant une
représentation de l'Immeuble.

Ecrivez aussi une classe de testBatiment afin de tester les classes.

Figure
Ecrivez une classe abstraite Figure avec les attributs suivants:

 nom: Le nom de la figure.

La classe Figure doit contenir des accesseurs et mutateurs pour les différents attributs
et les méthodes suivantes:

 aire(): L'aire de la figure (abstraite),


 toString(): Donne une représentation de la figure.

Ecrivez un classe Disque héritant de Figure avec les attributs suivants:

 centre: Le centre du disque,


 rayon: Le rayon du disque.

La classe Disque doit disposer des constructeurs suivants:


 Disque(),
 Disque(centre, rayon).

La classe Disque doit contenir des accesseurs et mutateurs pour les différents attributs
et les méthodes suivantes:

 aire(): Donne l'aire du disque,


 toString(): Donne une représentation du Disque.

Ecrivez un classe Rectangle héritant de Figure avec les attributs suivants:

 longueur: La longueur du rectangle,


 largeur: La largeur du rectangle.

La classe Rectangle doit disposer des constructeurs suivants:

 Rectangle(),
 Rectangle(longueur, largeur).

La classe Rectangle doit contenir des accesseurs et mutateurs pour les différents
attributs et les méthodes suivantes:

 aire(): Donne l'aire du rectangle,


 toString(): Donne une représentation du Rectangle.

Ecrivez aussi une classe de testFigure afin de tester les classes.


Utilisez les propriétés du polymorphisme.

Employé
Ecrivez une classe abstraite Employe avec les attributs suivants:

 nom: Le nom de famille de l'employé,


 prenom: Le prénom de l'employé.

La classe Employe doit disposer des constructeurs suivants:

 Employe(),
 Employe(nom, prenom).
La classe Employe doit contenir des accesseurs et mutateurs pour les différents
attributs et les méthodes suivantes:

 toString(): retourne une représentation d'un employé,


 gains(): retourne le salaire (abstraite).

Ecrivez une classe Patron héritant de Employé avec les attributs suivants:

 salaire : Le salaire mensuel.

La classe Patron doit disposer des constructeurs suivants:

 Patron(),
 Patron(nom, prenom, salaire).

La classe Patron doit contenir des accesseurs et mutateurs pour les différents attributs
et les méthodes suivantes:

 toString(): retourne une représentation du patron,


 gains(): retourne le salaire du patron.

Ecrivez une classe TravailleurCommission héritant de Employé avec les


attributs suivants:

 salaire : Le salaire mensuel de base,


 commission: Montant de la commission par article vendus,
 quantite: nombre d'articles vendus par mois.

La classe TravailleurCommission doit disposer des constructeurs suivants:

 TravailleurCommission(),
 TravailleurCommission(nom, prenom, salaire, commision).

La classe TravailleurCommission doit contenir des accesseurs et mutateurs pour les


différents attributs et les méthodes suivantes:

 toString(): retourne une représentation du travailleur à la commission,


 gains(): retourne le salaire du travailleur à la commission.
Ecrivez une classe TravailleurHoraire héritant de Employé avec les attributs suivants:

 retribution: La rétrubution horaire,


 heures: Le nombre d'heures de travail par mois.

La classe TravailleurHoraire doit disposer des constructeurs suivants:

 TravailleurHoraire(),
 TravailleurHoraire(nom, prenom, retribution).

La classe TravailleurHoraire doit contenir des accesseurs et mutateurs pour les


différents attributs et les méthodes suivantes:

 toString(): retourne une représentation du travailleur horaire,


 gains(): retourne le salaire du travailleur horaire.

Ecrivez aussi une classe de testEmploye afin de tester les classes.


Utilisez les propriétés du polymorphisme.

Forme
Ecrivez une interface Forme avec les méthodes abstraites suivantes:

 perimetre(): renvoie le périmètre de la forme,


 aire(): renvoie l'aire de la forme.

Ecrivez un classe Carre implémentant l'interface Forme avec les attributs


suivants:

 cote: Le côté du carré,

La classe Carre doit disposer des constructeurs suivants:

 Carre(),
 Carre(cote).

La classe Carre doit contenir des accesseurs et mutateurs pour les différents attributs
et les méthodes suivantes:
 perimetre(): Donne le périmètre du carré,
 aire(): Donne l'aire du carré,
 toString(): Donne une représentation du Carré.

Ecrivez aussi une classe de testForme afin de tester les classes.

Evénement
Ecrivez une application graphique avec une fenêtre (JFrame) contenant un bouton
(JButton). Ecrivez ensuite une classe interne pour la gestion des événements de ce
bouton afin d'afficher une boîte de dialogue.

GeoVecteur
Ecrivez une classe abstraite GeoVecteur avec les méthodes statiques suivantes:

 longueur(ux, uy, uz): renvoie la longueur du vecteur,


 produitScalaire(ux, uy, uz, vx, vy, vz) : retourne le produit scalaire de
deux vecteurs,
 produitVectoriel(ux, uy, uz, vx, vy, vz) : retourne le produit vectoriel de deux
vecteurs.

Ecrivez aussi une classe de testVecteur afin de tester les classes.

8-Caractères et chaînes
Exercices

 Exercice 1: Chaines immuables


 Exercice 2: Chaines modifiables
 Exercice 3: Caractères
 Exercice 4: Jetons
 Exercice 5: Calcul d'occurences
 Exercice 6: Code morse

Chaines immuables
Ecrivez une classe avec deux chaines de caractères immuables:
"Le chat joue" et " avec une souris". Affichez ensuite les informations
suivantes:
- La longueur de la première chaine,
- Le 5ème caractère de la première chaine,
- Du deuxième au cinquième caractère de la deuxième chaine,
- Le résultat de la comparaison des deux chaines
- Le résultat de la recherche de la chaine "sou" dans la deuxième chaine,
- La concaténation des deux chaines.

Chaines modifiables
Ecrivez une classe avec une chaine de caractères modifiable
"Le chat est là.". Effectuez ensuite les opérations suivantes:
- Affichez la chaine de caractère,
- Affichez la longueur de la chaine,
- Affichez la capacité de la chaine,
- Modifiez la longueur de la chaine à 14,
- Affichez la chaine de caractère,
- Afficher le 4ème caractère de la chaine,
- Modifiez le premier caractère de la chaine en "l",
- Affichez la partie de chaine du 4ème au 7ème caractère,
- Affichez la chaine à l'envers,
- Insérez le texte "Quand " au tout début de la chaine,
- Supprimer la partie "est" de la chaine de caractère,
- Insérez entre les deux espaces, la chaine "n'est pas",
- Ajoutez à la fin de la chaine ", les souris dansent.".

Caractères
Ecrivez une classe avec une variable caractère 'A'. Effectuez ensuite les
opérations suivantes:
- Afficher le caractère,
- Indiquer si le caractère est un chiffre,
- Indiquer si le caractère est une lettre,
- Vérifier si le caractère est un chiffre ou une lettre,
- Vérifier si le caractère est en minuscule,
- Indiquer si le caractère est en majuscule,
- Met et affiche le caractère en majuscule,
- Met et affiche le caractère en minuscule,
- Affiche le code ASCII du caractère.

Jetons
Ecrivez une classe permettant de tester la classe StringTokenizer permettant
de découper une chaine de caractères en jetons.
La classe doit afficher le nombre d'éléments et la liste des jetons.
Utilisez les chaines de caractères suivantes:
- "La première chaine à découper en jetons.",
- "La|seconde|chaine|à|découper|en|jetons.".
Calcul d'occurences
Ecrivez une classe permettant de calculer le nombre d'occurences de chaque
lettre de l'alphabet d'un texte. Utilisez un tableau pour enregister le
nombre d'occurences de chaque lettre.

Code morse
Le code Morse est le plus connu de tous les codages. Il est constitué d'une
suite de points (.) et de tirets (-). La séparation de mots est assurée par
un blanc: un espace.
Ecrivez une classe permettant de convertir une phrase en code Morse et vis
versa. Utilisez un blanc entre chaque lettre et trois blanc entre chaque mots.

Code morse:

A .- M -- Y -.--
B -... N -. Z --..
C -.-. O --- 0 -----
D -.. P .--. 1 .----
E . Q --.- 2 ..---
F ..-. R .-. 3 ...--
G --. S ... 4 ....-
H .... T - 5 .....
I .. U ..- 6 -....
J .--- V ...- 7 --...
K -.- W .-- 8 ---..
L .-.. X -..- 9 ----.

9-Traitement des exceptions


Exercices

 Exercice 1: Saisie entier


 Exercice 2: Division par zéro
 Exercice 3: Fonctionnement des exceptions
 Exercice 4: Saisie de longueurs

Saisie entier
Ecrivez une application qui demande à l'utilisateur de saisir un entier à l'aide d'une
boîte de dialogue. Tant que la valeur saisie est incorrecte, afficher un message d'erreur
et demander à nouveau la saisie. Si la valeur est correcte afficher un message de
confirmation.
Note : Utilisez un bloc try / Catch avec l'exception NumberFormatException.

Division par zéro


Ecrivez un programme contenant une classe d'exception de division par zéro héritant
de la classe ArithmeticException et une classe pour tester cette exception.
Cette classe de test est une application graphique contenant des étiquettes et des
champs pour le numérateur, le dénominateur et le quotient. Le programme doit
afficher un message d'erreur lorsqu'une des valeurs saisies n'est pas un entier ou
encore lorsque le dénominateur vaut zéro.

Fonctionnement des exceptions


Ecrivez une classe permettant d'illustrer le fonctionnement du bloc try / catch / finally.
Cette classe contient 2 méthodes, une qui lance une exception et l'autre qui ne lance
pas d'exception. Ces deux méthodes contienent un bloc try / catch / finally ne faisant
qu'afficher des messages de traces.

Saisie de longueurs
Ecrivez un programme contenant une classe d'exception de longueur négative héritant
de la classe ArithmeticException et une classe pour tester cette exception.
Cette classe de test est une application graphique qui contient une zone de texte pour
afficher les messages. Elle contient une méthode permettant la saisie d'une valeur de
longueur. La saisie est redemandée jusqu'à ce que celle-ci soit valide. Une boite de
dialogue d'erreur et une trace (printStackTrace) sont affichées lorsque la valeur saisie
n'est ni un entier ni une valeur positive.
Utilisez cette fonction pour demander la saisie de la longueur et de la largeur d'un
rectangle pour afficher ensuite les informations saisies et l'aire du rectangle.