PTD3 - Travaux Dirigés-Java

Département de génie électrique
Filière ingénieur
Systèmes Intelligents, Communicants et Mobiles
SICoM
Travaux dirigés
Programmation Orientée Java
Auteur :
Pr. Hicham GHENNIOUI
Page 2/43
Page 3/43
SOMMAIRE
OBJET ...................................................................................................................... 5
ENNONCES, TD 1 – TECHNIQUES DE BASE EN PROGRAMMATION
JAVA ........................................................................................................................ 7
1.1 EXERCICE 1 – CHAMPS STATIQUE ...................................................................................... 7
1.2 EXERCICE 2 – UTILISATION DE LA CLASSE WRAPPER ......................................................... 8
1.3 EXERCICE 3 – UTILISATION DE LA CLASSE STRINGBUFFER................................................ 8
1.4 EXERCICE 4 – CLASSE ABSTRAITE ..................................................................................... 9
ENNONCES, TD 2 – GESTION DES EXCEPTIONS......................................... 11
2.1 EXERCICE 1 – DETECTION ET TRAITEMENT DE L’EXCEPTION : DIVISION PAR ZERO ........ 11
2.2 EXERCICE 2 – UTILISATION DES METHODES DE LA CLASSE THROWABLE ......................... 11
2.3 EXERCICE 3 – EXCEPTION PERSONNALISEE DE LA DIVISION PAR ZERO ............................ 12
2.4 EXERCICE 4 – DEPASSEMENT DES BORNES D’UN TABLEAU ............................................... 12
3.1 EXERCICE 1 – UTILISATION DE LA CLASSE SCANNER ....................................................... 15
3.2 EXERCICE 2 – UTILISATION DE LA CLASSE BUFFEREDREADER ........................................ 15
3.3 EXERCICE 3 – STREAM DE DONNEES BONAIRES................................................................ 16
3.4 EXERCICE 4 – STREAM DE CARACTERES .......................................................................... 16
ENNONCES, TD 4 – PROGRAMMATION EVENEMENTIELLE .................. 17
4.1 EXERCICE 1 – PROGRAMMATION EVENEMENTIELLE AVEC AWT .................................... 17
4.1.1Trace d’un segment ............................................................................................................................ 17
4.1.2Trace d’un rectangle .......................................................................................................................... 17
4.1.3Affichage des polices disponibles........................................................................................................ 18
4.1.4Création d’une étiquette ..................................................................................................................... 18
4.1.5Création des case à cocher ................................................................................................................. 18
4.1.6Création des boutons radio ................................................................................................................. 19
4.1.7Création d’une liste déroulante .......................................................................................................... 19
4.1.8Création d’une liste à choix multiple – 1- ........................................................................................... 19
4.1.9Création d’une liste à choix multiple – 2- ........................................................................................... 20
4.1.10
Création bouton avec événement ........................................................................................................ 20
4.2 EXERCICE 2 – PROGRAMMATION EVENEMENTIELLE AVEC SWING................................... 21
4.2.1 Bonjour en swing ............................................................................................................................... 21
4.2.2 Création d’une applet « Bonjour » ..................................................................................................... 22
4.2.3 Création d’une applet « Couleur du fond » ........................................................................................ 22
4.2.4 Création d’une applet « Image » ........................................................................................................ 22
CORRIGES, TD 1 – TECHNIQUES DE BASE EN PROGRAMMATION

JAVA ...................................................................................................................... 25
5.1 EXERCICE 1 – CHAMPS STATIQUE .................................................................................... 25
5.1 EXERCICE 2 – UTILISATION DE LA CLASSE WRAPPER ....................................................... 26
5.2 EXERCICE 3 – CLASSE STRINGBUFFER............................................................................. 27
5.3 EXERCICE 4 – CLASSE ABSTRAITE ................................................................................... 27
5.1 EXERCICE 5 – HERITAGE SIMPEL .................................................................................... 28
CORRIGES, TD 2 – GESTION DES EXCEPTIONS ......................................... 29
6.1 EXERCICE 1 – DETECTION ET TRAITEMENT DE L’EXCEPTION : DIVISION PAR ZERO ........ 29
6.2 EXERCICE 2 – UTILISATION DES METHODES DE LA CLASSE THROWABLE......................... 29
6.3 EXERCICE 3– EXCEPTION PERSONALISEE DE LA DIVISION PAR ZERO ............................... 30
6.4 EXERCICE 4 – DEPASSEMENT DES BORNES D’UN TABLEAU ............................................... 31
CORRIGES, TD 3 – PROGRAMMATION ORIENTE OBJET EN C++ ......... 33
Page 4/43
7.1 EXERCICE 1 – UTILISATION DE LA CLASSE SCANNER ....................................................... 33

7.2 EXERCICE 2 – UTILISATION DE LA CLASSE BUFFEREDREADER ........................................ 33
7.3 EXERCICE 3 – STREAM DE DONNEES BONAIRES................................................................ 34
7.4 EXERCICE 4 – STREAM DE CARACTERES .......................................................................... 34
CORRIGES, TD 4 – PROGRAMMATION EVENEMENTIELLE ................... 37
8.1 EXERCICE 1 – PROGRAMMATION EVENEMENTIELLE AVEC AWT .................................... 37
8.1.1Trace d’un segment ............................................................................................................................ 37
8.1.2Trace d’un rectangle .......................................................................................................................... 37
8.1.3Affichage des polices disponibles........................................................................................................ 38
8.1.4Création d’une étiquette ..................................................................................................................... 38
8.1.5Création des case à cocher ................................................................................................................. 38
8.1.6Création des boutons radio ................................................................................................................. 39
8.1.7Création d’une liste déroulante .......................................................................................................... 39
8.1.8Création d’une liste à choix multiple -1-............................................................................................. 40
8.1.9Création d’une liste à choix multiple -2-............................................................................................. 41
8.1.10
Création bouton avec événement ........................................................................................................ 41
8.2 EXERCICE 2 – PROGRAMMATION EVENEMENTIELLE AVEC SWING................................... 42
8.2.1 Bonjour en swing ............................................................................................................................... 42
8.2.2 Création d’une applet « Bonjour » ..................................................................................................... 43
8.2.3 Création d’une applet « Couleur du fond » ........................................................................................ 43
8.2.4 Création d’une applet « Image » ........................................................................................................ 43
Page 5/43
OBJET
Ce document concerne les travaux dirigés du module "Programmation Orientée

Objet Java " de la filière du cycle ingénieur en "Systèmes Intelligents, Communicants
et Mobiles" (SICoM) de la Faculté des Sciences et Techniques de Fès (FSTF).
Ces travaux dirigés traitent en particulier,
- les techniques de base en programmation Java,

- la gestion des exceptions,
- la lecture des entrées clavier,
- la gestion des fichiers,
- et la programmation événementielle java..
Pour en tirer un bon profit de ces séances de travaux dirigés, il est conseillé de
préparer tous les exercices avant l’arrivé en salle de TD.
Page 6/43
Enoncés
Page 7/43
ENNONCES, TD 1 – TECHNIQUES DE BASE EN PROGRAMMATION JAVA
1.1 EXERCICE 1 – CHAMPS STATIQUE

On considère le code Java suivant,
L1. public class ChampsStatique {

L2. static int compteur1 = 0; int compteur2 = 0;
L3. ChampsStatique(){compteur1++; compteur2++; }
L4. public static void main(String[] args) {
L5. System.out.println("Valeur du compteur 1 (statique): " + ChampsStatique.compteur1);
L6. System.out.println("Valeur du compteur 2" + ChampsStatique.compteur2);
L7. ChampsStatique Objet1= new ChampsStatique();
L8. System.out.println("Compteur 1: " + Objet1.compteur1 + "Compteur 2: " + Objet1.compteur2);

L10. System.out.println("Compteur 1:"+Objet2.compteur1 + " Compteur 2: "+Objet2.compteur2);
L11. System.out.println("Valeur du compteur 1 (statique): " + ChampsStatique.compteur1);}}
1. Quelle est la ligne qui produit l’erreur ?

2. Remplir le tableau suivant,
Ligne Résultat
L5 ………………………………………………………………………………………………
L6 ………………………………………………………………………………………………
L8 ………………………………………………………………………………………………
L10 ………………………………………………………………………………………………
L11 ………………………………………………………………………………………………
Page 8/43
1.2 EXERCICE 2 – UTILISATION DE LA CLASSE WRAPPER

L1. public class UtilisationWrapper {

L3. String strPrimitif = "3.14";
L4. float ftPrimitif = 3.14F;
L5. Float objetFt;
L6. ftPrimitif = Float.MAX_VALUE; /
L7. System.out.println("La plus grande valeur flottante est : " + ftPrimitif);
L8. ftPrimitif = Float.MIN_VALUE;
L9. System.out.println("La plus petite valeur flottante est : " + ftPrimitif);
L10. objetFt = new Float(ftPrimitif);
L11. ftPrimitif = objetFt.floatValue();
L12. objetFt = Float.valueOf(strPrimitif);
L13. strPrimitif= objetFt.toString();
L14. System.out.println("La valeur convertie de Float en String : " + strPrimitif);
L15. strPrimitif = Float.toString(ftPrimitif);
L16. System.out.println("La valeur convertie de float en String : " + strPrimitif);
L17. ftPrimitif = Float.parseFloat(strPrimitif);
L18. System.out.println("La valeur convertie de String en float: " + ftPrimitif);}}
Expliquer les lignes L6., L8., L10., L11., L12., L13., L15. et L17.
1.3 EXERCICE 3 – UTILISATION DE LA CLASSE STRINGBUFFER

On considère le code Java erroné suivant,
L1. public class ChaineCaracteres {

L3. String str="Hello";
L4. System.out.println(str);
L5. System.out.println("La longueur de la chaine " + str + " est :" + str.length());
L6. StringBuffer str1= new StringBuffer(str);
L6. str1.append(" tout le monde");
L7. System.out.println(str1 + " de taille :" + str1.length());
L8. str1.setLength(str.length());
L9. System.out.println("devient : " + str1 + " de taille :" + str1.length() );}}
Page 9/43
Remplir le tableau suivant,
Ligne Résultat
L5 ………………………………………………………………………………………………
L6 ………………………………………………………………………………………………
L7 ………………………………………………………………………………………………
L9 ………………………………………………………………………………………………
1.4 EXERCICE 4 – CLASSE ABSTRAITE

On considère le modèle suivant,
Compléter le code suivant,
public ……………………………….……. class Forme {
String Nom;
………………. ……………..…. ………..………. ……………………………();}

Page 10/43
public class Rectangle ……………………… . ……………………………… {
double longueur, largeur;
………………….. (…………… ……………….., (…………… ………………..){
………………………. =longueur; ……………………… =largeur; }
public …………………………… calculPerimetre() {
return 2*(longueur+largeur); }
public class Cercle ……………………… . ……………………………… {
double rayon;
……………………………(………………………. ………………..) {
……………………….=rayon; }
public ………………………. calculPerimetre() {
return 2 * ……………………….*rayon ;}
public class UtilisationClasseAbstraiteN {
public static void main(String[] args) {
………………………. Rect = new …………………………………..);
………………………. cerc= new ……………………….;
System.out.println("Périmètre du rectangle est : " + ……………………….);
System.out.println("Périmètre du cercle est : " + ……………………….);
}}
Page 11/43
ENNONCES, TD 2 – GESTION DES EXCEPTIONS
2.1 EXERCICE 1 – DETECTION ET TRAITEMENT DE L’EXCEPTION : DIVISION

PAR ZERO
Ecrire un programme Java permettant de détecter et de traiter l’exception de la division par zéro.
L’exécution du programme affiche le message ci-dessous,
Indication :
- Le premier bloc de try{} contient l’erreur (j/i)
- Le second bloc catch(ArithmeticException e){} contient le traitement à faire. Par exemple,
afficher le message "Une exception arithmétique est levée".
2.2 EXERCICE 2 – UTILISATION DES METHODES DE LA CLASSE THROWABLE

On considère le programme Java suivant,

Ligne Résultat
12 ………………………………………………………………………………………………
14 ………………………………………………………………………………………………
16 ………………………………………………………………………………………………
Page 12/43
2.3 EXERCICE 3 – EXCEPTION PERSONNALISEE DE LA DIVISION PAR ZERO

Ecrire une exception personnalisée de la division personnalisée.
Indication :
- Etape 1 : Créer et définir une classe fille de la classe Exception
public class SaisieException extends Exception {
public SaisieException() {
super();
}
public SaisieException(String s) {
super(s);
}
}
- Etape 2 : créer et définir la classe contenant la méthode principale
Créer une classe qui contient la méthode principale. Cette classe contient la méthode qui génère
l’exception,
public static void controledivisionParZeros(int m) throws SaisieException
2.4 EXERCICE 4 – DEPASSEMENT DES BORNES D’UN TABLEAU

public class TableauException {
public static void main(String[] args){
int n=3; //nombre de valeurs
double P[] = new double [n]; /* P contient les chaînes et les
anti-chaînes*/
int attribut = 1 ;/*compteur des attributs*/
int nb_cas_possible = 1;/* Nombre de fois possible
qu'attribut traité doit garder la même valeur*/
int k = 1; // Nombre de point
int aspect_traite = 0;
double puiss = 0; // contient le résultat la fonction
calculer
System.out.println("les elements de p sont: ");
while(k < n){
for(int i= 0; i<n; i++){
P[k]= i;
k ++ ;
nb_cas_possible = nb_cas_possible *n;
attribut = attribut+1;
aspect_traite = 1;
System.out.println("nombre d attribut= "+
attribut);
System.out.println("le nombre de cas traite: "+
nb_cas_possible);
}
}
for(int j=0; j< P.length; j++){
System.out.print("P["+j+"]= ");
System.out.print(P[j] + " ");
System.out.println();
}
}
}
L’exécution de ce programme fournit le résultat suivant,
Page 13/43
1. Pour quelle valeur de k et i l’erreur est produite ?

2. Corriger le programme en gérant une exception
Page 14/43
Page 15/43
ENNONCES, TD 3 – LECTURE DES ENTREES CLAVIER & GESTION DES

FICHIER
3.1 EXERCICE 1 – UTILISATION DE LA CLASSE SCANNER

Ecrire un programme Java permettant de demander à l’utilisateur de saisir,
Entrée Indication
un mot nextLine()
un entier nextInt()
Un flottant nextFloat()
Un caractère charAt(0)
Voici un exemple du résultat d’exécution du programme,
3.2 EXERCICE 2 – UTILISATION DE LA CLASSE BUFFEREDREADER

Ecrire un programme Java permettant de sommer des entiers entrés par un utilisateur tant qu'il y a
des lignes non. Vides.
Indication
1 – Importer les classes suivantes nécessaires pour lire le clavier,
BufferedReader; InputStreamReader; StringTokenizer;
2- Importer la classe de la gestion des exceptions,
IOException;
3- Utiliser le mot throws pour génrer l’exception au niveau de la méthode principale,
public static void main (String[] argv) throws IOException,
NumberFormatException { …}
Page 16/43
3- Créer création de l'objet entrée de type BuffredReader,

BufferedReader entree = new BufferedReader(new
InputStreamReader(System.in));
4- Créer un objet avec argument ligne,
st = new StringTokenizer(ligne);// ligne est lue par readLine()
5 – Faire appel à la méthode hasMoreTokens qui est une méthode booléene de la classe
StringTokenizer qui teste s'il y'a encore des caractères
6 – Sommer les entiers entrés par le clavier,
somme += Integer.parseInt(st.nextToken());
Un exemple du résultat d’exécution du programme est le suivant,
3.3 EXERCICE 3 – STREAM DE DONNEES BONAIRES

1. Ecrire un programme Java permettant d’écrire dans un fichier binaire les données suivantes,
Bonjour SICoM Students, 2017, p et false
2. Ensuite afficher sur l’écran la taille à l’aide de la méthode size.
3. Ecrire un programme java permettant de lire le fichier binaire crée dans la question 1.
3.4 EXERCICE 4 – STREAM DE CARACTERES

1. Reprendre l’exercice 3 en considérant l’écriture dans un fichier de caractère au lieu un
fichier binaire.
2. Lire maintenant les données du fichier crée et afficher le contenu du fichier sur l’écran.
3. Ecrire un programme permettant de copier un fichier texte vers un autre fichier texte.
Utiliser les méthodes write et read (condition de EOF : objet.read())!=-1).
Page 17/43
ENNONCES, TD 4 – PROGRAMMATION EVENEMENTIELLE
4.1 EXERCICE 1 – PROGRAMMATION EVENEMENTIELLE AVEC AWT
4.1.1 TRACE D’UN SEGMENT

Ecrire une classe fille de la classe prédéfinie Frame permettant de tracer un segment reliant le point
(50,150) au (65,200).
Le résultat d’exécution du programme doit être comme ci-dessous,
4.1.2 TRACE D’UN RECTANGLE

Ecrire une classe fille de la classe prédéfinie Frame permettant de tracer deux Rectangles vide et
plein de paramètres : largeur= 150, hauteur= 100, couleur= rouge et coordonnées du coin supérieur
gauche du rectangle = 50 et 60.
Page 18/43
4.1.3 AFFICHAGE DES POLICES DISPONIBLES

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher les polices disponibles
(coordonnées (20,20), (20,20+20), (20,40+20),…).
4.1.4 CREATION D’UNE ETIQUETTE

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher une étiquette sur la
fenêtre. La taille de l’étiquette est (400,400).
Indication : créer l’objet de type Label à l’intérieur du constructeur de la classe, ensuite faire appel
à la méthode add.
4.1.5 CREATION DES CASE A COCHER

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher une case à cocher sur la
fenêtre.
Page 19/43
4.1.6 CREATION DES BOUTONS RADIO

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher cinq boutons radio.
4.1.7 CREATION D’UNE LISTE DEROULANTE

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher une liste déroulante de
trois éléments (menu) : jaune, rouge et bleu. Une fois, un élément est choisi, la couleur d’arrière
plan de la fenêtre change.
4.1.8 CREATION D’UNE LISTE A CHOIX MULTIPLE – 1-

Ecrire un programme permettant d’écrire au maximum 10 éléments dans une liste à multiples choix
autorisant la sélection multiple.
Rajouter deux boutons : un pour ajouter et l’autre pour supprimer un (des) élément(s)
Rappel :
- La méthode add est obligatoire pour ajouter un composant
- La classe FlowLayout permet la mise à jour l’interface (setLayout)
- La méthode action(Event e, Object o) permet de définir l’action à faire (e.target==boutton
pour tester sur le boutton est pressé)
Page 20/43
4.1.9 CREATION D’UNE LISTE A CHOIX MULTIPLE – 2-

Ecrire un programme permettant d’écrire au maximum 10 éléments dans une 2 ème liste à multiples
choix autorisant la sélection multiple à partir de la 1 ère liste à simple choix n’autorisant pas la
sélection multiple.
- Rajouter deux boutons : un pour ajouter un élément sélectionné de la 1ère liste dans la 2ème
liste et l’autre pour supprimer un (des) élément(s) de la 2 ème liste
- Faire le test si l’élément existe déjà avant de le rajouter
4.1.10 CREATION BOUTON AVEC EVENEMENT

Ecrire un programme permettant de tracer un cercle rouge si on clique sur le bouton « trace » et
d’effacer ce cercle si on clique sur le bouton « effacer »
Rappel :
 Utiliser l’interface ActionListener qui hérite de l’interface EventListener. Votre classe
implémente cette interface définissant la méthode actionPerformed
public class EvenementBouton extends Frame implements ActionListener
 Affecter un adaptateur pour les événements de type ActionEvent au bouton au moyen de
l’instruction trace.addActionListener(this)
Page 21/43
 Un événement de type java.awt.Event.ActionEvent se produit lorsqu’on clique sur le bouton

« trace » et la méthode actionPerformed est automatiquement invoquée. Le même principe
s’applique pour le bouton « effacer »
 Mise à jour de l’interface
setLayout(new FlowLayout(FlowLayout.CENTER,5,5));
 Tester le clic sur « trace » : e.getSource() == trace
 Changer la clouleur : g.setColor(Color.red);
 Tracer cercle : g.drawOval(100, 100, 100, 100);
Rajouter un bouton « fermer» pour fermer l’interface
4.2 EXERCICE 2 – PROGRAMMATION EVENEMENTIELLE AVEC SWING
4.2.1 BONJOUR EN SWING

Ecrire un programme Java qui permet d’afficher « Bonjour » sur une fenêtre en utilisant le package
swing.
Page 22/43
4.2.2 CREATION D’UNE APPLET « BONJOUR »

Ecrire une applet qui affiche une chaîne de caractère à la position (20,25).
4.2.3 CREATION D’UNE APPLET « COULEUR DU FOND »

Ecrire une applet qui affiche une couleur jaune du fond de l’applet avant le démarrage (Indication :
redéfinir init())
4.2.4 CREATION D’UNE APPLET « IMAGE »

Ecrire une applet qui affiche une image
Page 23/43
Corrigés
Page 24/43
Page 25/43
CORRIGES, TD 1 – TECHNIQUES DE BASE EN PROGRAMMATION JAVA
5.1 EXERCICE 1 – CHAMPS STATIQUE

L1. public class ChampsStatique {

L2. static int compteur1 = 0; int compteur2 = 0;
L3. ChampsStatique(){compteur1++; compteur2++; }
L5. System.out.println("Valeur du compteur 1 (statique): " + ChampsStatique.compteur1);
L6. System.out.println("Valeur du compteur 2" + ChampsStatique.compteur2);
L8. System.out.println("Compteur 1: " + Objet1.compteur1 + "Compteur 2: " + Objet1.compteur2);

L10. System.out.println("Compteur 1:"+Objet2.compteur1 + " Compteur 2: "+Objet2.compteur2);
L11. System.out.println("Valeur du compteur 1 (statique): " + ChampsStatique.compteur1);}}
1. Quelle est la ligne qui produit l’erreur ?

La L6. produit une erreur
2. Remplir le tableau suivant,
Ligne Résultat
L5 Valeur du compteur 1 (statique): 0
L6 Produit une erreur. Il faut la mettre en commentaire (//)
L8 Valeur du compteur 1: 1 et Valeur du compteur 2: 1
L10 Valeur du compteur 1: 2 et Valeur du compteur 2: 1
L11 Valeur du compteur 1 (statique): 2

Page 26/43
5.1 EXERCICE 2 – UTILISATION DE LA CLASSE WRAPPER

L1. public class UtilisationWrapper {

L3. String strPrimitif = "3.14";
L4. float ftPrimitif = 3.14F;
L5. Float objetFt;
L6. ftPrimitif = Float.MAX_VALUE; /
L7. System.out.println("La plus grande valeur flottante est : " + ftPrimitif);
L8. ftPrimitif = Float.MIN_VALUE;
L9. System.out.println("La plus petite valeur flottante est : " + ftPrimitif);
L10. objetFt = new Float(ftPrimitif);
L11. ftPrimitif = objetFt.floatValue();
L12. objetFt = Float.valueOf(strPrimitif);
L13. strPrimitif= objetFt.toString();
L14. System.out.println("La valeur convertie de Float en String : " + strPrimitif);
L15. strPrimitif = Float.toString(ftPrimitif);
L16. System.out.println("La valeur convertie de float en String : " + strPrimitif);
L17. ftPrimitif = Float.parseFloat(strPrimitif);
L18. System.out.println("La valeur convertie de String en float: " + ftPrimitif);}}
Expliquer les lignes L6., L8., L10., L11., L12., L13., L15. et L17.
Ligne Explication
L6. Plus grande valeur positive de type float
L8. Plus petite valeur positive de type float
L10. Conversion float -> Float
L11. Conversion Float -> float
L12. Conversion String -> Float
L13. Conversion Float -> String
L15. Conversion float -> String
L17. Conversion String -> float
Page 27/43
5.2 EXERCICE 3 – CLASSE STRINGBUFFER

On considère le code Java erroné suivant,
L1. public class ChaineCaracteres {

L3. String str="Hello";
L4. System.out.println(str);
L5. System.out.println("La longueur de la chaine " + str + " est :" + str.length());
L6. StringBuffer str1= new StringBuffer(str);
L6. str1.append(" tout le monde");
L7. System.out.println(str1 + " de taille :" + str1.length());
L8. str1.setLength(str.length());
L9. System.out.println("devient : " + str1 + " de taille :" + str1.length() );}}
Ligne Résultat
L5 Hello
L6 La longueur de la chaine Hello est :5
L7 Hello tout le monde de taille :19
L9 devient : Hello de taille :5
5.3 EXERCICE 4 – CLASSE ABSTRAITE

On considère le modèle suivant,
Page 28/43
Compléter le code suivant,
public abstract class Forme {
String Nom;
public abstract double calculPerimetre();}
public class Rectangle extends Forme {
double longueur, largeur;
Rectangle (double longueur, double largeur){
this.longueur =longueur; this.largeur =largeur; }
public double calculPerimetre() {
return 2*(longueur+largeur); }
}
public class Cercle extends Forme {
5.1 EXERCICE 5 – HERITAGE SIMPEL
double rayon;
Cercle(double rayon) {
this.rayon =rayon; }
public double. calculPerimetre() {
return 2 * Math.PI *rayon ;}
public class UtilisationClasseAbstraiteN {
Rectangle Rect = new Rectangle(2,4);
Cercle cerc= new Cercle(1);
System.out.println("Périmètre du rectangle est : " + rect.calculPerimetre());
System.out.println("Périmètre du cercle est : " + cerc.calculPerimetre());
}}
Page 29/43
CORRIGES, TD 2 – GESTION DES EXCEPTIONS
6.1 EXERCICE 1 – DETECTION ET TRAITEMENT DE L’EXCEPTION : DIVISION

PAR ZERO
//Exemple 1 de détection et traitement de l'exception : division par zéro
//F.I. SICoM, FSTF
//Hicham Ghennioui
//A.U. 2017-2018
public class ExempleException1 {
int i = 0, j=30;
try{
System.out.println("Resultat = "+ j/i);
}
catch(ArithmeticException e){
System.out.println("Une exception arithmétique est levée");
}
}
}
6.2 EXERCICE 2 – UTILISATION DES METHODES DE LA CLASSE THROWABLE

//Exemple 2 d’utilisation des méthodes de la classe Throwble
//F.I. SICoM, FSTF, Hicham Ghennioui
//A.U. 2017-2018
public class ExempleException2 {
int i = 0, j=30;
try{
System.out.println("Resultat = "+ j/i);
}
catch(ArithmeticException e){
System.out.println("Une exception arithmétique est levée");
System.out.println("Lecture du message" + e.getMessage());
System.out.println("toString");
System.out.println(e.toString());
System.out.println("L'exception et l'état de la pile
d'exécution au moment de son appel sont");
e.printStackTrace( );
}
}
}
Page 30/43
Ligne Résultat
12 Lecture du message/ by zero
14 java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
16 at ExempleException2.main(ExempleException2.java:8)
6.3 EXERCICE 3– EXCEPTION PERSONALISEE DE LA DIVISION PAR ZERO

Ecrire une exception personnalisée de la division personnalisée.
Indication :
- Etape 1 : Créer et définir une classe fille de la classe Exception
public class SaisieException extends Exception {
public SaisieException() {
super();
}
public SaisieException(String s) {
super(s);
}
}
- Etape 2 : créer et définir la classe contenant la méthode principale
Créer une classe qui contient la méthode principale. Cette classe contient la méthode qui génère
l’exception,
public static void controledivisionParZeros(int m) throws SaisieException
public class ExceptionPersonnaliseeDivisionParZeros{

public static void controledivisionParZeros(int m) throws SaisieException {
if (m == 0)
throw new SaisieException("Erreur: division par zéro");
}
public static void main(java.lang.String[] args){
int n=10, m1=5, m=0;
try {controledivisionParZeros(m1);} catch (SaisieException e) {
System.out.println("m1" +e.getMessage());
}
try {controledivisionParZeros(m);} catch (SaisieException e) {
System.out.println("m = 0 " +e.getMessage());
}
}
}
Page 31/43
6.4 EXERCICE 4 – DEPASSEMENT DES BORNES D’UN TABLEAU

double P[] = new double [n]; /* P contient les chaînes et les
anti-chaînes*/
int nb_cas_possible = 1;/* Nombre de fois possible
qu'attribut traité doit garder la même valeur*/
double puiss = 0; // contient le résultat la fonction
calculer
while(k < n){
P[k]= i;
k ++ ;
aspect_traite = 1;
System.out.println("nombre d attribut= "+
attribut);
nb_cas_possible);
}
}
System.out.println();
}
}
}
L’exécution de ce programme fournit le résultat suivant,
3. Pour quelle valeur de k et n l’erreur est produite ?

k=3 et i=2
4. Corriger le programme en gérant une exception
Page 32/43
//int p = n;//nombre d'attribut
double P[] = new double [n]; /* P contient les chaînes et les anti-
chaînes*/
int nb_cas_possible = 1;/* Nombre de fois possible qu'attribut
traité doit garder la même valeur*/
double puiss = 0; // contient le resultat la fonction calculer
//double t[] = {1,2,4};
while(k < n){

try {
P[k]= i;
} catch (Exception e) {
System.err.println("Erreur k="+k+ " i=" + i);
}
k ++ ;
aspect_traite = 1;
System.out.println("nombre d attribut= "+ attribut);
nb_cas_possible);
}
}

}
}
}
Page 33/43
CORRIGES, TD 3 – PROGRAMMATION ORIENTE OBJET EN C++
7.1 EXERCICE 1 – UTILISATION DE LA CLASSE SCANNER

Ecrire un programme Java permettant de demander à l’utilisateur de saisir un mot, un entier, un
flottant et un caractère,
import java.util.Scanner; //Importer la classe Scanner

public class UtilisationClasseScanner {
Scanner scobj = new Scanner(System.in); //Création d'un objet Scanner
System.out.println("Veuillez saisir un mot :");
String str = scobj.nextLine(); //Lire un mot
System.out.println("Vous avez saisi : " + str);
System.out.println("Veuillez saisir un entier :");
int n = scobj.nextInt(); //Lire un entier
System.out.println("Vous avez saisi : " + n);
System.out.println("Veuillez saisir un flottant :");
float f = scobj.nextFloat(); //Lire un mot
System.out.println("Vous avez saisi : " + f); //Faites attention utiliser
//virgule au lieu de point. Exemple : 7,5
System.out.println("Veuillez saisir un caractère :");
scobj.nextLine(); // on vide la ligne avant d’en lire une autre
Scanner scobj1 = new Scanner(System.in);
String str1 = scobj1.nextLine();
char carac = str1.charAt(0);
System.out.println("Vous avez saisi le caractère : " + carac);
}}
7.2 EXERCICE 2 – UTILISATION DE LA CLASSE BUFFEREDREADER

Ecrire un programme Java permettant de sommer des entiers entrés par un utilisateur tant qu'il y a
des lignes non. Vides.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class UtilisationClasseBufferedReader {
public static void main (String[] argv) throws IOException, NumberFormatException {
int somme = 0;
String ligne;
StringTokenizer st;
System.out.println("Entrez les nombre à sommer :");
BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));
ligne = entree.readLine(); //permet la lecture à partir du clavier
while(ligne.length() > 0) { //tant qu'il y a des lignes non vides
st = new StringTokenizer(ligne); //création d'un objet st avec argument ligne
while(st.hasMoreTokens())/*hasMoreTokens est une méthode booléene de la classe
StringTokenizer qui teste s'il y'a encore des caractères*/
somme += Integer.parseInt(st.nextToken());//somme des entiers entrés clavier
ligne = entree.readLine();
}
System.out.println("La somme vaut : "+somme);
}
}
Page 34/43
7.3 EXERCICE 3 – STREAM DE DONNEES BONAIRES

1. Ecrire un programme Java permettant d’écrire dans un fichier binaire les données suivantes,
Bonjour SICoM Students, 2017, p et false
2. Ensuite afficher sur l’écran la taille à l’aide de la méthode size.
//Hicham Ghennioui
import java.io.*;
public class EcritureFichierBinaire {
public static void main(String[] args) throws IOException {
DataOutputStream e; //Flux de sortie
e = new DataOutputStream(new FileOutputStream("TestFile"));
e.writeUTF("Bonjour SICoM Students");
e.writeInt(2017); //écrire un entier
e.writeChar('p'); //écrire un caractère
e.writeBoolean(false); //écrire un booléen
System.out.println("La taille est "+e.size());
e.close(); }}
3. Ecrire un programme java permettant de lire le fichier binaire crée dans la question 1.
import java.io.*;
public class LectureFichierBinaire {
DataInputStream l;
l = new DataInputStream(new FileInputStream("TestFile"));
System.out.println(l.readUTF());
System.out.println(l.readInt());
System.out.println(l.readChar());
System.out.println(l.readBoolean());
l.close();
}
}
7.4 EXERCICE 4 – STREAM DE CARACTERES

1. Reprendre l’exercice 3 en considérant l’écriture dans un fichier de caractère au lieu un
fichier binaire.
import java.io.*;
public class EcritureFichierTexte {
PrintWriter e;
int i = 2017;
e = new PrintWriter(new FileOutputStream("TexttFile.txt"));
e.println("Hello SICoM Students");
e.println("Y a-t-il des absents?");
e.println(i);
e.close();
}
}
2. Lire maintenant les données du fichier crée et afficher le contenu du fichier sur l’écran.
import java.io.*;
public class LectureFichierTexte {
public static void main(String[] args) throws IOException{
BufferedReader r = null;
String l;
try{
r = new BufferedReader (new FileReader("TexttFile.txt"));
}
Page 35/43
catch(FileNotFoundException e){
System.out.println("Erreur d'ouverture du fichier!");
}
while((l = r.readLine())!= null)
System.out.println(l);
r.close();
}
3. Ecrire un programme permettant de copier un fichier texte vers un autre fichier texte.
Utiliser les méthodes write et read (condition de EOF : objet.read())!=-1).
import java.io.*;
public class CopierFichierTexte {
int i;
FileReader r = new FileReader("TexttFile.txt");
FileWriter e = new FileWriter("CTextFile.txt");
while((i=r.read())!=-1)
e.write(i);
r.close();
e.close();
}
}
Page 36/43
Page 37/43
CORRIGES, TD 4 – PROGRAMMATION EVENEMENTIELLE
8.1 EXERCICE 1 – PROGRAMMATION EVENEMENTIELLE AVEC AWT
8.1.1 TRACE D’UN SEGMENT

Ecrire une classe fille de la classe prédéfinie Frame permettant de tracer un segment reliant le point
(50,150) au (65,200).
import java.awt.*;
public class Exemple51Segment extends Frame {
Exemple51Segment(String titre){
super(titre); //appel du constructeur de la classe mère : appel
automatique de la méthode paint
}
//Redéfinition de la méthode paint
public void paint(Graphics g){
g.setColor(Color.blue);
//dessiner une ligne de 2 pixels d'épaisseur
g.drawLine(50, 65, 150, 200);
g.drawLine(50, 66, 150, 201);
}
// Appel du constructeur de la classe Frame
//La méthode paint est automatiquement appelée pour dessiner une fenêtre cachée
Exemple51Segment Segment = new Exemple51Segment("Un segment");
Segment.setSize(400,400);
Segment.setVisible(true);//rendre le composant visible (méthode de la classe Component)
}}
8.1.2 TRACE D’UN RECTANGLE

Ecrire une classe fille de la classe prédéfinie Frame permettant de tracer deux Rectangles vide et
plein de paramètres : largeur= 150, hauteur= 100, couleur= rouge et coordonnées du coin supérieur
gauche du rectangle = 50 et 60.
import java.awt.*;
public class Exemple52Rectangle extends Frame {
int x=50, y=60; //coordonnées du coin supérieur gauche du rectangle
int largeur = 150, hauteur = 100; //Dimensions du rectangle
Color couleur = Color.red; //Déclaration d'un objet Couleur
Exemple52Rectangle(String titre){
super(titre);
}
g.setColor(couleur);
g.drawRect(x, y, largeur, hauteur);
g.fillRect(x, y+150, largeur, hauteur); //Rectangle plein à partir de
(x, y+150)
}
Exemple52Rectangle rectangle = new Exemple52Rectangle("Deux rectangles");
rectangle.setSize(400,400);
rectangle.setVisible(true);
}}
Page 38/43
8.1.3 AFFICHAGE DES POLICES DISPONIBLES

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher les polices disponibles
(coordonnées (20,20), (20,20+20), (20,40+20),…).
import java.awt.*;
public class Exemple53Polices extends Frame {
Exemple53Polices(String titre){super(titre);}
int x=20, y=20;
String polices[]=getToolkit().getFontList();
for (int i=0;i<polices.length; i++){
g.drawString(polices[i],x,y);
y+=20;
}
}
Exemple53Polices listPolices = new Exemple53Polices("Polices");
listPolices.setSize(400,400);
listPolices.setVisible(true);
}
}
8.1.4 CREATION D’UNE ETIQUETTE

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher une étiquette sur la
import java.awt.*;
//Une étiquette est une chaîne de caractères ne dépassant pas une ligne
public class Exemple54Etiquette extends Frame {
Label etiquette; //déclaration d'un objet de la classe Label
Exemple54Etiquette(String titre){
super(titre);
etiquette = new Label("Exemple d'une étiquette");
add(etiquette); //affichage de l'étiquette sur la fenêtre
}
Exemple54Etiquette monEtiquette = new Exemple54Etiquette("Affichage
étiquette");
monEtiquette.setSize(400,400);
monEtiquette.setVisible(true);
}
}
8.1.5 CREATION DES CASE A COCHER

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher une case à cocher sur la
import java.awt.*;
public class Exemple55CaseACocher extends Frame {
static boolean etat = false; //case est non cochée
Checkbox test; //nouvelle case à cocher
Exemple55CaseACocher(String titre){ super(titre);
FlowLayout fl = new FlowLayout();//gestionnaire de mise en page
/*FlowLayout place les composants ligne par ligne de gauche à droite
tous les élements sont mis côte à
*côte, de gauche à droite. Lorsqu'il n'y a plus assez de place pour
ajouter un élément, on passe à la ligne
*suivante. Les lignes sont centrées par défaut */
setLayout(fl);//méthode la classe Container utilisée pour qu'une
Page 39/43
nouvelle mise en page soit effective
test = new Checkbox("Test");
add(test); }
public boolean action(Event e, Object arg){
if (test.getState()){ etat = true; repaint();/*force
l'exécution de la méthode paint(). elle permet
d'informer le programme d'un changement dans la fenêtre graphique */
}
else{etat = false; repaint();}
return(true);}
public void paint(Graphics g){g.setColor(Color.red);g.setFont(new
Font("Helevetica",Font.BOLD,20));
if (etat == true) g.drawString("Case activée", 50, 300);
else g.drawString("Case désactivée", 50, 300);}
Exemple55CaseACocher maCase = new Exemple55CaseACocher("Case à
cocher");
maCase.setSize(400,400); maCase.pack();//on demande de choisir la
taille min
maCase.setVisible(true); }}
8.1.6 CREATION DES BOUTONS RADIO

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher cinq boutons radio.
import java.awt.*;
public class Exemple56BoutonRadio extends Frame {
CheckboxGroup status; //déclaration d'un groupe de boutons radio
Checkbox celibataire, marie, divorce, veuf, autre;
Exemple56BoutonRadio(String titre){
super(titre);
FlowLayout fl = new FlowLayout(FlowLayout.LEFT,40,0);
setLayout(fl);
celibataire = new Checkbox("Célibataire", true, status);
add(celibataire);
marie = new Checkbox("Marié", false, status);
add(marie);
divorce = new Checkbox("Divorcé", false, status);
add(divorce);
veuf = new Checkbox("Veuf", false, status);
add(veuf);
autre = new Checkbox("Autre", false, status);
add(autre);
}
Exemple56BoutonRadio monStatus = new Exemple56BoutonRadio("Status");
monStatus.setSize(400,400);
monStatus.setVisible(true);
}}
8.1.7 CREATION D’UNE LISTE DEROULANTE

Ecrire une classe fille de la classe prédéfinie Frame permettant d’afficher une liste déroulante de
trois éléments (menu) : jaune, rouge et bleu. Une fois, un élément est choisi, la couleur d’arrière
plan de la fenêtre change.
import java.awt.*;
public class Exemple57ListeDeroulante extends Frame {
String str; //contient la couleur choisie
Choice choix = new Choice(); //création une liste de choix
Exemple57ListeDeroulante(String titre){
super(titre);
Page 40/43
choix.addItem("Jaune"); choix.addItem("Rose");
choix.addItem("Bleu");
add(choix);//affichage de la liste déroulante
}
public boolean action(Event e, Object arg){
str = (String)arg;
repaint();
return(true);
}
if(str == "Jaune") setBackground(Color.yellow);
else
if(str == "Rose") setBackground(Color.pink);
else
if(str == "Bleu") setBackground(Color.blue);
}
Exemple57ListeDeroulante monChoix = new Exemple57ListeDeroulante("Couleur
de l'arrière plan");
monChoix.setSize(400,400);
monChoix.setVisible(true);}}
8.1.8 CREATION D’UNE LISTE A CHOIX MULTIPLE -1-

Ecrire un programme permettant d’écrire au maximum 10 éléments dans une liste à multiples choix
autorisant la sélection multiple.
Rajouter deux boutons : un pour ajouter et l’autre pour supprimer un (des) élément(s)
import java.awt.*;
public class Exemple59ListeChoixMultiple extends Frame {
List li1 = new List(10,true);
//List li2 = new List(10,true);
Button b1 = new Button("Ajouter");
Button b2 = new Button("Supprimer");
Exemple59ListeChoixMultiple(String titre){
super(titre);
FlowLayout fl = new FlowLayout();
setLayout(fl);
add(b1);
add(b2);
li1.addItem("Elet1");li1.addItem("Elet2");
//li1.addItem("Elet5");li1.addItem("Elet6");
add(li1);
//add(li2);
}
public boolean action(Event e, Object o){
if(e.target==b1) //si le boutton b1 est cliqué
li1.addItem("autre");
else if (e.target==b2){
int indice[]=li1.getSelectedIndexes();
for (int i=0; i<indice.length;i++)
li1.delItem(indice[i]);
}
return true;
}
Exemple59ListeChoixMultiple maListe = new
Exemple59ListeChoixMultiple("Liste d'éléments");
maListe.setSize(400,400);
maListe.setVisible(true);
}}
Page 41/43
8.1.9 CREATION D’UNE LISTE A CHOIX MULTIPLE -2-

Ecrire un programme permettant d’écrire au maximum 10 éléments dans une 2 ème liste à multiples
choix autorisant la sélection multiple à partir de la 1 ère liste à simple choix n’autorisant pas la
sélection multiple.
- Rajouter deux boutons : un pour ajouter un élément sélectionné de la 1 ère liste dans la 2ème
liste et l’autre pour supprimer un (des) élément(s) de la 2 ème liste
- Faire le test si l’élément existe déjà avant de le rajouter
import java.awt.*;
public class Exemple59ListeChoixMultipleBis extends Frame {
List li1 = new List(10,false);
List li2 = new List(10,true);
Button b1 = new Button("Ajouter");
Button b2 = new Button("Supprimer");
Button b3 = new Button("Fermer");
Exemple59ListeChoixMultipleBis(String titre){
super(titre);
FlowLayout fl = new FlowLayout();
setLayout(fl);
add(b1);
add(b2);
add(b3);
add(li1);
add(li2);
}
public boolean action(Event e, Object o){
if(e.target==b1){ //si le boutton b1 est pressé
li2.addItem(li1.getSelectedItem());
li1.delItem(li1.getSelectedIndex());
}
else if (e.target==b2){
int indice[]=li2.getSelectedIndexes();
for (int i=0; i<indice.length;i++)
li2.delItem(indice[i]);
}
else if (e.target==b3)
System.exit(0);
return true;
}
Exemple59ListeChoixMultipleBis maListe = new
Exemple59ListeChoixMultipleBis("Liste d'éléments");
maListe.setSize(700,400);
maListe.setVisible(true);
}
}
8.1.10 CREATION BOUTON AVEC EVENEMENT

Ecrire un programme permettant de tracer un cercle rouge si on clique sur le bouton « trace » et
d’effacer ce cercle si on clique sur le bouton « effacer »
Page 42/43
Rajouter un bouton « fermer» pour fermer l’interface

import java.awt.*;
import java.awt.event.*;
class Exemple60ClicBouton extends Frame implements ActionListener,

WindowListener{
Button trace = new Button("Trace");
Button effacer = new Button("Effacer");
Button fermer = new Button("Fermer");
Exemple60ClicBouton(){
setLayout(new FlowLayout(FlowLayout.CENTER,5,5));
add(trace);
add(effacer);
add(fermer);
trace.addActionListener(this);
effacer.addActionListener(this);
fermer.addActionListener(this);
}
public void actionPerformed(ActionEvent e){
Graphics g =getGraphics();
if (e.getSource() == trace){
g.setColor(Color.red);
g.drawOval(100, 100, 100, 100);
}
else if (e.getSource() == effacer){
g.setColor(getBackground());
g.drawOval(100, 100, 100, 100);
}
else if (e.getSource() == fermer){
System.exit(0);
}
}
Exemple60ClicBouton monCadre = new Exemple60ClicBouton();
monCadre.setSize(300,300);
monCadre.setVisible(true);
}
}
8.2 EXERCICE 2 – PROGRAMMATION EVENEMENTIELLE AVEC SWING
8.2.1 BONJOUR EN SWING

Ecrire un programme Java qui permet d’afficher « Bonjour » sur une fenêtre en utilisant le package
swing.
import javax.swing.*;
import java.awt.*;
public class Exemple61FrameSwing extends JFrame {
Exemple61FrameSwing (){
super("Première application Swing");
Container cp = getContentPane();
JLabel label = new JLabel("Bonjour", SwingConstants.CENTER);
cp.add(label, BorderLayout.CENTER);
}

JFrame f = new Exemple61FrameSwing();
//f.setBounds(200,200,150,100);
f.setTitle("Première Application Swing");
Page 43/43
f.setSize(300,200);
f.setVisible(true);
}
8.2.2 CREATION D’UNE APPLET « BONJOUR »

Ecrire une applet qui affiche une chaîne de caractère à la position (20,25).
import java.applet.Applet;
import java.awt.Graphics;
public class HelloApplet extends Applet {
g.drawString("Hello SICoM Students",20,25);
}
}
8.2.3 CREATION D’UNE APPLET « COULEUR DU FOND »

Ecrire une applet qui affiche une couleur jaune du fond de l’applet avant le démarrage (Indication :
redéfinir init())
import java.applet.*;
import java.awt.*;
public class FondJaune extends Applet{
public void init( ) {
this.setBackground(Color.yellow); }}
8.2.4 CREATION D’UNE APPLET « IMAGE »

Ecrire une applet qui affiche une image
public void paint(Graphics g) {
super.paint(g);
Image image=null;
image=getImage(getDocumentBase( ), "monimage.gif"); /*chargement de
l'image */
g.drawImage(image, 40, 70, this); /*drawImage() est un objet qui implémente l'interface ImageObserver
déclarée dans le package java.awt.image qui sert à donner des informations sur le fichier image*/
}

PTD3 - Travaux Dirigés-Java

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

PTD3 - Travaux Dirigés-Java

Transféré par

Droits d'auteur :

Formats disponibles

Département de génie électrique

CORRIGES, TD 1 – TECHNIQUES DE BASE EN PROGRAMMATION

7.1 EXERCICE 1 – UTILISATION DE LA CLASSE SCANNER ....................................................... 33

Ce document concerne les travaux dirigés du module "Programmation Orientée

- les techniques de base en programmation Java,

ENNONCES, TD 1 – TECHNIQUES DE BASE EN PROGRAMMATION JAVA

1.1 EXERCICE 1 – CHAMPS STATIQUE

L1. public class ChampsStatique {

L9. ChampsStatique Objet2= new ChampsStatique();

1. Quelle est la ligne qui produit l’erreur ?

1.2 EXERCICE 2 – UTILISATION DE LA CLASSE WRAPPER

L1. public class UtilisationWrapper {

1.3 EXERCICE 3 – UTILISATION DE LA CLASSE STRINGBUFFER

L1. public class ChaineCaracteres {

Remplir le tableau suivant,

1.4 EXERCICE 4 – CLASSE ABSTRAITE

Compléter le code suivant,

public ……………………………….……. class Forme {

………………. ……………..…. ………..………. ……………………………();}

public class Rectangle ……………………… . ……………………………… {

double longueur, largeur;

………………….. (…………… ……………….., (…………… ………………..){

………………………. =longueur; ……………………… =largeur; }

public …………………………… calculPerimetre() {

public class Cercle ……………………… . ……………………………… {

public ………………………. calculPerimetre() {

public class UtilisationClasseAbstraiteN {

public static void main(String[] args) {

………………………. Rect = new …………………………………..);

………………………. cerc= new ……………………….;

System.out.println("Périmètre du rectangle est : " + ……………………….);

System.out.println("Périmètre du cercle est : " + ……………………….);

ENNONCES, TD 2 – GESTION DES EXCEPTIONS

2.1 EXERCICE 1 – DETECTION ET TRAITEMENT DE L’EXCEPTION : DIVISION

2.2 EXERCICE 2 – UTILISATION DES METHODES DE LA CLASSE THROWABLE

Remplir le tableau suivant,

2.3 EXERCICE 3 – EXCEPTION PERSONNALISEE DE LA DIVISION PAR ZERO

2.4 EXERCICE 4 – DEPASSEMENT DES BORNES D’UN TABLEAU

1. Pour quelle valeur de k et i l’erreur est produite ?

ENNONCES, TD 3 – LECTURE DES ENTREES CLAVIER & GESTION DES

3.1 EXERCICE 1 – UTILISATION DE LA CLASSE SCANNER

Voici un exemple du résultat d’exécution du programme,

3.2 EXERCICE 2 – UTILISATION DE LA CLASSE BUFFEREDREADER

3- Créer création de l'objet entrée de type BuffredReader,

Un exemple du résultat d’exécution du programme est le suivant,

3.3 EXERCICE 3 – STREAM DE DONNEES BONAIRES

3.4 EXERCICE 4 – STREAM DE CARACTERES

ENNONCES, TD 4 – PROGRAMMATION EVENEMENTIELLE

4.1 EXERCICE 1 – PROGRAMMATION EVENEMENTIELLE AVEC AWT

4.1.1 TRACE D’UN SEGMENT

4.1.2 TRACE D’UN RECTANGLE

4.1.3 AFFICHAGE DES POLICES DISPONIBLES

4.1.4 CREATION D’UNE ETIQUETTE

4.1.5 CREATION DES CASE A COCHER

4.1.6 CREATION DES BOUTONS RADIO

4.1.7 CREATION D’UNE LISTE DEROULANTE

4.1.8 CREATION D’UNE LISTE A CHOIX MULTIPLE – 1-

Le résultat d’exécution du programme doit être comme ci-dessous,

4.1.9 CREATION D’UNE LISTE A CHOIX MULTIPLE – 2-

4.1.10 CREATION BOUTON AVEC EVENEMENT

 Un événement de type java.awt.Event.ActionEvent se produit lorsqu’on clique sur le bouton

4.2 EXERCICE 2 – PROGRAMMATION EVENEMENTIELLE AVEC SWING

4.2.1 BONJOUR EN SWING