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

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, essayez 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, deplacer(x, y),

translater(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 les 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() donnant 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.