- une version PanelDateA avec une classe de handler définie comme une classe interne anonyme

PARTIE 4

FICHE F Interfaces graphiques

Séquence "JavaFX et Programmation événementielle"

Exercice FX-PE 1 *

Tester le compteur de click vu en cours

Exercice FX-PE 2 *

Définir une classe PanelDate dérivée de BorderPane permettant, grâce à un bouton "Mettre à jour la date" d'actualiser une date affichée dans un label. (la date affichée dans ce label est donc la date au moment du dernier click sur le bouton)

Exercice FX-PE 3 **

Définir une classe PanelTempsEntreDeuxClick dérivée de BorderPane. Le panel est composé d’un label et d’un bouton. Lors du click sur le bouton, on note grâce au label le temps en secondes écoulé depuis le click précédent.

Séquence "JavaFX et classes internes"

Exercice 2.3

Ecrire le programme du 2.1 avec :

- une version PanelDateI avec une classe de handler définie comme une classe interne non anonyme. (pour cette version, déclarer en attribut du panel les composants graphiques utilisés dans le handler)

- une version PanelDateA avec une classe de handler définie comme une classe interne anonyme

- une version PanelDateL en utilisant une lambda expression

Exercice 3 IGCouleurBouton *

Définir une classe PanelCouleurBouton avec deux boutons - un bouton de texte "couleur rouge" et de couleur rouge - un bouton de texte "couleur verte" et de couleur verte - un label de text "Je change de couleur"

Faire le nécessaire pour que les deux boutons modifient la couleur du texte du label (le foreGround (setTextFill) du label) : rouge ou vert

La modification du background peut être faite par l’affectation d’un style CSS : Exemple : boutonVert.setStyle("-fx-background-color:green;");

Exercice 4 IGLien *

Définir une classe LabelLien dérivée de Label telle que lors du passage de la souris sur le composant, le foreground du label soit modifié.

Exercice 5 IGSecret **

L'objectif de cet exercice est d'implémenter une interface graphique pour le jeu du nombre secret (l'ordinateur doit trouver un nombre compris entre 1 et 100 et l'utilisateur du programme lui donne des indications).

Ci-dessous le source de la classe Jeu que vous devez utiliser sans modification.

Définir la classe PanelJeuDuNombreSecret et une classe

EcouteurJeuDuNombreSecret à l'écoute des clicks sur les boutons de l'interface.

Définir ensuite une classe principale pour tester le jeu.

Test du jeu :

La commande permettant d'exécuter un jar auto exécutable est : java - jar

<adresse du fichier jar> Exemple : java - jar nombreSecret.jar

public class Jeu {


 /** le nombre minimum a trouver */


private int minInitial;


/** le nombre maximum a trouver */


private int maxInitial;


 /** au cours d'un jeu, le minimum déduit à partir des réponses précédentes*/


private int min;


 /** au cours d'un jeu, le maximum deduit à partir des reponses precedentes*/


private int max;
 


private int nbPropositions;
 


private boolean gagne = false;
 


public Jeu(int minInitial, int maxInitial) { this.minInitial = minInitial;

this.maxInitial = maxInitial;

reset();

}
 


/** le jeu est redemarre */


public void reset() { this.min = minInitial;

this.max = maxInitial;

this.gagne = false;

this.nbPropositions=0;

}
 


/** @return true si le jeu est sans solution */


public boolean isJeuSansSolution() { return this.min > this.max;

}


 
 /** @return true si le joueur a gagne*/


 public boolean isGagne() { return this.gagne;

}


 
 /* retourne la proposition de l'ordinateur*/


public int getProposition() {
 
return (this.min + this.max) / 2;
 
}
 
 public int getNbPropositions( ){
 return this.nbPropositions;
 }
 
 /* rajoute 1 au minimum */


public void noterPropositionTropPetite() { this.nbPropositions++;

this.min = this.getProposition() + 1;


 }


 
 /*enleve 1 au maximum*/
public void noterPropositionTropGrande() { this.nbPropositions++;

this.max = this.getProposition() - 1;

}
 


/*le maximum et le minimum prend la valeur du chiffre recherche qui vient
 d'etre trouve*/


public void noterPropositionOK() { this.nbPropositions++;

this.min = this.getProposition();

this.max = this.min;

this.gagne = true;

}
 }

Fiche G Entrées sorties Exercice 1 filestream


Question a
Définir une fonction écrivant dans un fichier deux bytes.
 Tester la fonction avec les bytes 195 et 169. 
Ouvrir ce fichier avec un éditeur de texte.

Que remarquez-vous ?
 `

Question b
Définir une fonction permettant d'afficher les bytes contenus dans un fichier.


Question c
En utilisant les classes FileReader et BufferedReader, définir une fonction statique qui étant donné un File rend la chaîne de caractères

représentant le contenu du fichier.


Question d
Si l'on souhaite préciser l'encodage (UTF-8,Cp1252,ISO8859-1), il faut utiliser comme Reader un InputStreamReader.
 Définir une fonction

statique qui étant donné un File et un encodage rend la chaîne de caractères représentant le contenu du fichier.
 


Exemple de méthode main pour tester cet exercice :


public static void main(String[] args) throws IOException{


File file = new File("exemple.txt");


System.out.println("File : "+file.getAbsolutePath());


// question a


writeTwoBytes(file, 195,169);


// question b


 printBytesFromFile(file); // affiche 195 169
 // question c


System.out.println(getStringFromFile(file)); // affiche é ou affiche é


//questiond


 System.out.println(getStringFromFile(file,"UTF-8")); //é


System.out.println(getStringFromFile(file,"ISO-8859-1")); // é


}


 
 Exercice 2 copiefichier
 Question a


Définir une fonction permettant la copie d'un fichier dans un autre en utilisant BufferedInputStream et BufferedOutputStream


Question b


Définir une fonction permettant la copie d'un fichier dans un autre sans utiliser BufferedInputStream ni BufferedOutputStream
Pour définir cette fonction, on utilisera la méthode public int read(byte[] tb) de la classe InputStream et la méthode public void write(byte[] tb) de la classe OutputStream


Question c


Définir une fonction permettant la copie d'un répertoire (directory) dans un autre. 
 


Exercice 3 sérialisation de tableaux
 Question a

Ecrire un programme permettant d'enregistrer dans un fichier un tableau d'entiers sérialisé

Question b

Ecrire un autre programme permettant de récupérer ce tableau sérialisé et d'afficher les éléments de ce tableau

Exercice 4 Sérialisation de répertoire

Ajouter à la classe RepertoireSD (ou RepertoireS) deux méthodes l'une

permettant de sauvegarder par sérialisation dans un File donné un répertoire et l'autre permettant de récupérer un répertoire sérialisé dans un File.

Ces deux méthodes lance une exception RepertoireException en cas de problème. (on définira la classe RepertoireException)

Entête de la méthode sauvegarder :

public void sauvegarder (File file) throws RepertoireException

Exercice 5 JAVAFX, répertoire, sérialisation et gestion d'exception **

On pourra reprendre la classe RepertoireSD précédemment définie.

Définir une interface graphique permettant de : - récupérer un répertoire sérialisé

- le sauvegarder - ajouter une entrée

- récupérer un numéro de téléphone connaissant un nom Prévoir d'avertir l'utilisateur en cas d'erreur.

Fiche I Threads Exercice 1

Tester les exemples du cours (ThreadAfficheLettre et ThreadDate) 
 (pour ThreadAfficheLettre, on pourra faire varier le nombre de lettres à afficher, faire une pause (Thread.sleep) entre chaque affichage ...)

Exercice 2 threaddate

En reprenant l'exercice sur le compteur de click,

ajouter un label affichant l'heure et assurer un rafraichissement de l'heure toutes les secondes

Exercice 3 sync

On considère la classe Sync. (vous trouverez le fichier Sync.java dans ressources_td.zip)


- que fait la méthode main de programme ?


- pourquoi l'exécution ne donne pas le résultat que l'on pourrait attendre ? 
 - utiliser un bloc synchronized pour obtenir un résultat correct

Exercice 4 threadballe

Vous trouverez dans ressources_td.zip le fichier Balle.java et un jar

autoexécutable threadballe.jar.
 Utiliser la classe balle pour faire évoluer n balles sur un terrain de 400 par 400 pixels.
threadballe.jar vous permet de voir le rendu souhaité.

FICHE M SAX

Exercice 1

Tester l’exemple vu en cours avec la classe Repertoire

- tester le programme générant un xml à partir d’un répertoire

- tester le programme parsant un fichier xml pour construire un répertoire - tester avec validation

o (redéfinir la méthode error de DefaultHandler en lançant une exception puis vérifier en modifiant le nom d’une balise qu’une erreur se produit.) - tester avec utilisation d’un espace de noms

- tester avec validation et utilisation d’un espace de noms

Exercice 2

Faire un travail analogue avec une classe Compte

- Choisir une classe Compte très simple (addOperation getHistorique getSolde) - créer dans un éditeur texte un exemple de fichier xml représentant un compte - créer le programme générant un xml à partir d’un objet compte

- créer le programme parsant un fichier xml pour construire un compte Avec validation

- créer le fichier xsd

- parser avec validation (vérifier un mettant une balise non prévue) Avec espace de noms

Choisir comme espace de noms pour les balises du compte : www.mi.parisdescartes/licinfo/mll5u2o

- Parser sans validation - Parser avec validation

FICHE N JUnit

Exercice Junit 1 : Faire des tests unitaires pour l'exercice D6

Exercice Junit 2 : Faire des tests unitaires pour les méthodes de la classe DicoT9 (ressources JUNIT DICOT9) (On utilisera @Before)

Exercice junit 3 : Faire des tests unitaires paramétrés pour la méthode recuperer de la classe DicoT9

Exercice Junit 4 : Faire des test unitaires pour la classe LigneMetro (Ressources TD : metro2012)

FICHE P Maven

Exercice 1

a- Créer un projet Maven avec l’archetype QuickStart

b- Créer une classe et définir la fonction rendant la somme des racines carrées de deux entiers

c- utiliser une commande maven pour produire le jar de ce projet

d- faire une fonction main permettant à l’utilisateur de donner à partir du terminal deux entiers et affichant le résultat dans ce terminal.

e- refaire le jar du projet

f- créer une classe de test avec deux fonctions testant la fonction précédente (dont une pour le test avec des entiers négatifs)

(attention : le plugin surefire de maven ne considère comme classe de tests que les classes dont le nom commence par Test ou se termine par Test ou TestCase) g- utiliser une commande maven pour faire les tests unitaires

h- produire le site web avec la javadoc et le résultat des tests unitaires

Exercice 2

Les classes LigneMetro, Station, Ratp et Main du package lignemetro.base sont récupérables dans le repository

http://www.mi.parisdescartes.fr/~pary/java/repository grâce à :

<dependency>

<groupId>up5.mi.pary.metro12</groupId>

<artifactId>metrobase</artifactId>

<version>1.0</version>

</dependency>

Le site du projet metrobase est à l'adresse :

http://www.math-info.univ-paris5.fr/~pary/java/sites/metrobase/1.0/

- Créer un projet maven où vous définissez la classe Pane - faire un jar exécutable du projet

FICHE Q Log4J

Exercice 1

- Définir un projet maven avec les deux classes ci-dessous.

- Remplacer tous les appels à System.out.println par des appels log4j.

- Définir un fichier de configuration permettant que tous les messages soient affichés dans la console et que les affichages importants soient mis dans un fichier.

public class Main {

public static void main(String[] args) {

int [] donnees = {5,34,432};

try{

for (int donnee:donnees){

System.out.println("Resultat "+donnee+" "+ Util.fact(donnee));

}

}

catch (Exception exp){

System.out.println("Erreur fatale : sortie du programme :"+

exp.getMessage());

} } }

public class Util {

public static BigInteger fact(int n){

System.out.println("--> fact("+n+")=?");

if (n<0) {

System.out.println("Fact : l'argument doit etre positif ou nul :"+n);

throw new IllegalArgumentException(

"Fact : l'argument doit etre positif ou nul :"+n);

}

BigInteger res;

if (n==0)

res=BigInteger.ONE;

else res=fact(n-1).multiply(BigInteger.valueOf(n));

System.out.println("<-- fact("+n+")="+res);

return res;

} }

FICHE R classes internes Exercice R1

On considère les classes et interface suivantes :

public interface Fonc1 {

Integer call(Integer arg);

}

public class PlusUn implements Fonc1{

public Integer call(Integer elt){

return elt+1;

} }

public class Util {

public static List<Integer> appliquerSurChaqueElement(List<Integer> list, Fonc1 fonc) {

List<Integer> res = new ArrayList<>();

for (Integer elt:list)

res.add(fonc.call(elt));

return res;

} }

Question a

Définir une fonction main utilisant la fonction appliquerSurChaqueElement avec la liste [5 9 16] et rendant comme résultat la liste [6 10 17]

Question b

On souhaite pouvoir obtenir un résultat analogue à celui obtenu avec la classe PlusUn mais on souhaite pouvoir ajouter un autre entier que 1.

Définir une autre classe que l’on appellera PlusN implémentant Fonc1 avec un constructeur prenant en parametre l’entier qui sera à ajouter.

Faire le test avec la liste [5 9 16] en ajoutant 10 pour obtenir [15 19 26]

Question c

Refaire le test de la question 1 mais en utilisant une classe locale définie dans la fonction main que l’on appelera PlusUnLocale

Question d

En utilisant une classe locale anonyme, obtenir comme résultat la multiplication par deux de chaque élément de la liste

Question e

Traiter la question 4 en utilisant une lambda expression