IHM :Interface Homme – Machine**Interactions système).

tème). Les deux classes principales : *Les nœuds sans enfants = feuilles ; *un Séparation entre l’interface graphique et la 📌 Constructeurs buton qu'une interface ne contient que des
Homme – Machine**Dialogue Homme – *Component : classe de base pour tous les parent peut avoir plusieurs enfants. gestion des événements. Réutilisation : Un Gestion d’events utiliser prototypes de méthodes et de propriétés
Machine objets graphiques (boutons, champs de texte, *L’ensemble forme un graphe de scène sous gestionnaire peut être réutilisé dans plusieurs :button.setOnAction(handler); *Une classe peut implémenter plusieurs
L’interface homme machine ‐ est un ensemble fenêtres…)*Container : sous‐classe de forme d’arbre, avec un nœud racine (sans parties de l’application **********CSS ET JAVAFX********* interfaces, mais elle ne peut hériter que d'une
de dispositifs matériels et logiciels permettant Component qui peut contenir d’autres parent). Event Object : classe de base Java pour CSS via le package javafx.css. JavaFX utilise classe (abstraite ou autre)
de contrôler et de communiquer avec une composants(fenêtre principale, panneau) *Tous les nœuds dérivent de la classe Node ; définir les évents :java.util un style par défaut appelé modena.css, *Une interface définit un ensemble de
machine. *****************Swing********* exemples : Classe Event : La classe de base des intégré dans le runtime JavaFX. méthodes (signatures) sans implémentation.
L’interaction homme machine ‐ est une action *Introduit en 1997, initialement comme librairie Parent, Group, Region, Control. événements JavaFX: javafx.event.Event. Style.css par exemple : .Button { Et Les classes qui l'implémentent doivent
qui provoque une réaction perceptible. Elle séparée pour Java 1.1, puis intégré dès Java ***Dispositions (Layouts) en JavaFX****** Rôle: Encapsulation des infos sur un event ‐fx‐background‐color: #3498db; ‐fx‐text‐fil: fournir le code pour chaque méthode.
regroupe des notions telles que les clics 1.2*Extension de AWT, offrant des composnts Les panneaux de disposition gèrent le (source, type....Chaque event représenté par white; ‐fx‐font‐size: 14px;} * Plusieurs classes peuvent implémenter
souris, la frappe de touches, les pressions sur graphiques plus riches et plus flexibles. placement des éléments dans une scène.Ex: un objet Event. Ou dans le code java : différemment une même interface
un écran tactile, etc. *Caractéristiques principales : FlowPane : organise les éléments en flux Méthodes Utiles : La classe Event propose Scene scene = new Scene(root, 400, 300); **Classes enveloppes : Permet de manipuler
Le dialogue Homme Machine ‐ est l'ensemble **Composants légers : Swing ne dépend pas (séquentiel). des méthodes pour obtenir des détails sur scene.getStylesheets().add(getClass().getRes les types primitifs comme des objets Boolean,
des échanges entre un utilisateur et une des composants graphiques natifs, les élémts GridPane : disposition en grille l'événement, comme getSource() ource("styles.css").toExternalForm()); Char acter, Byte, Short, Integer, Long, Float <
machine. Ces échanges regroupent les sont dessinés par le moteur graph Java. (lignes/colonnes). getEventType(). *****************JAVA = > boolean, char, byte,
manipulations avec un écran tactile, **Pluggable look and feel : possibilité de BorderPane : zones : haut, bas, gauche, Sous-classes courantes : ActionEvent : toString() : Bien entendu, il est toujours short, int, long, float
l’utilisation d'un microphone, d'un scanner, changer dynamiquement l'apparence des droite, centre. événements d'action (ex. clic sur un possible de redéfinir la méthode toString. * toutes les classes enveloppes disposent
d'une table à digitaliser, etc. interfaces pour imiter différents styles Tous les panneaux héritent de Node. bouton)*MouseEvent : actions de la souris Par exemple, dans notre classe Point, nous d’un constructeur recevant un argument d’un
Les interfaces utilisateur GUI qui intègre ces **Cohérence multiplateforme : même Node->Parent->Pane->HBOX/VBOX (clic, déplacement...)*KeyEvent : actions du pourrions lui faire fournir une chaîne type primitif:
élément apparence et même comportement sur toutes ***JavaFX : Classe Application et cycle de clavier (touche pressée...) contenant les coordonnées du point… Integer mObj = new Integer(12); // mObj
graphique sont parfois désignées par les plateformes. vie*** Une application JavaFX hérite **setOnKeyPressed() :*capte l'appui sur une Methode equals : Il compare les @de deux contient une référence à un objet de t ype
l'acronyme WIMP: *Avantages sur AWT : **Composants plus d’Application (package javafx.application). touche et affiche son code dans la console.. object concernés Integer encapsulant la valeur 12
Window : Notion de "fenêtre" Icon : Éléments personnalisables. ***Méthodes du cycle de vie : Exple syntaxe: boolean equals{Point p){ return *Elles disposent toutes d’une méthode de la
graphiques visuels. Menu : Choix d'actions **Interfaces plus cohérentes d'une plateforme init():Appelée en 1er Sert aux initialisations scene.setOnKeyPressed(event -> { (p.x=x)&&(p.y=y);}} forme xxxValue (xxx représentant le nom du
parmi une liste proposée Pointer : à l'autre.+Gestion améliorée des interfaces (pas de création de scène/stage).*Surcharge S.o.P ("Code de la touche : " + Types de classes/Interface: type promitif) qui permet de retrouver la
Curseur/Pointeur manipulé par la souris, et utilisateur pour les applications modernes. optionnelle(implémentation vide par défaut). event.getCode())}); # class et methode finales : *Var final = cte valeur dans le type primitif Correspond.
qui permet d'interagir avec les composants ********javaFX****** Caractéristiques : start(Stage primaryStage)Appelée après init(). *****EventHandler****** Un EventHandler en *Metho final = ne peut pas etre redefinie Int n = nObj.intValue();//n contient 12
visuels. Contrôles Modernes *Graphique de Scène *Obligatoire : méthode abstraite, doit la JavaFX est une interface qui sert à réagir aux *Class final = ne peut être dérivée Emballage (autoboxing) :Conversion d’un type
JavaFX est une collection de *Architecture MVC *Déploiement Simplifié surcharger. *Sert à créer et afficher la scène événements (clics, frappes clavier, etc.). *Class non final + tous les methode final = primitif→ objet wrapper.
classe,d'interface qui définit l'interface Support CSS et FXML. principale. Quand un event se produit, JavaFX appelle la class non final Integer nObj = 12; // équivalent à
graphique utilisateur (GUI) moderne de Java. ⚡ JavaFX : création des interfaces stop():Appelée à la fin de l’application.*Sert méthode handle() de l’EventHandler pour *Class abst = ne permt ps d’instancier un objt Integer.valueOf(12)
JavaFX simplifie la création d'une application ➡ Manière déclarative *Interface décrite en aux tâches de nettoyage.*Surcharge exécuter une action. *Methode abst = doit etre redefinie + contient Déballage (unboxing)Conversion d’un objet
en facilitant la gestion de ses eléments GUI et FXML. optionnelle (implémentation vide par défaut). void handle(T event); que des signatures que l’ntete wrapper→type primitif.
le déploiement de l'application. *Création facilitée par SceneBuilder. *Bonne *Lancement de l'application launch(args) : Une interface fonctionnelle : une interface qui =>Regles : int n = nObj; // équivalent à nObj.intValue()
Composants lourds :composants liés à la séparation présentation / logique (MVC). Démarre l'application.*Crée une instance de n’a qu’une seule méthode abstraite *class contient une ou plusieurs meth abst = *****enumeration****
plate‐forme locale d'exécution, car ils sont sous‐classe Application. *Reste active jsq'à la ***Implémenter un EventHandler class abst (m si on pas ecrit le mot abs) Définition :Un type énuméré (enum) définit un
➡ Manière procédurale
implémentés en code natif du SE hôte et la fermeture de l'app (ensuite stop()). Classe Anonyme:créer le EventHandler *Une class dérivée d’une classe non abs peut ensemble fini de constantes.Exemple :
*Interface construite par code Java (API).
Java Machine y fait appel lors de main() :Appelle launch.*Pas strictement oblig, directement dans le code, sans faire de classe être déclarée abst et/ou contenir des métho enum Jour {LUNDI, MARDI, MERCREDI,
*Plus flexible : création dynamique,
l'interprétation du prog Java. mais recommandé pour compatibilité. séparée. Cela rend le code + court mais peut- abstraites JEUDI, VENDREDI, SAMEDI, DIMANCHE}
extensions possibles.
Composants légers: comme ceux de la bib ****Squelette d'une Application JavaFX**** être moins clair. * Une classe abstraite peut comporter un ou Il existe également dans la classe Enum, une
Les 2 method peuv être combinées grâce à
Swing, sont entièrement implémentés en Java, ***Note :Log : Les System.out.println sont button.setOnAction(new plusieurs constructeurs, mais ils ne peuvent méthode nommée ordinal qui fournit le rang
javafx.fxml
ce qui les rend indépendants du système juste pour montrer l'ordre d'appel des EventHandler<ActionEvent>() pas être abstrait d’une valeur donnée dans la liste des
Une application JavaFX peut être installé :
d'exploitation sous‐jacent, : méthodes. {public void handle(ActionEvent e) { Class B extends A { Public void g( int) (…) ; } constantes du type; la première valeur est de
localement ou sur un serveur et intégrée dans
L’architecture de type MVC est une ****Commande de compilation**** System.out.println("Bouton cliqué !");}}); A a = new B(…) rang0.
une page web
architecture qui sépare le stockage des --module-path:indique où sont les fichiers.jar Expression Lambda:est une façon rapide de interface : *Une classe pourra implémenter Mardi.ordinal() vaut 1 ///Après l’affectation:
*****Structure des Paquets :***
données, leur représentation et les de JavaFX. créer des méthodes.Elle rend le code très plusieurs interfaces # une classe ne pouvait Avec switch
Le framework JavaFX est organisé en plus de
interactions possibles avec les données, les --add-modules javafx.controls : ajoute les concis, surtout pour de petits EventHandler. dériver que d’une seule classe abstraite ou switch (courant) { case LUNDI:// ... break;
30 paquets qui commencent par le préfixe
composants sont associés à différentes modules nécessaires pr les contrôles graph. button.setOnAction(e ‐> S.O.P("Bouton cliqué non *Dans la définition d’une interface, on ne case MARDI:// ...break;}
javafx. Exemples :
interfaces de modèles de base : But :Assurer que le compilateur trouve toutes !")); peut trouver que des en‐têtes de méthodes ou Conversion et itération
javafx.application : Contient des classes pour
Le Modèle chargé de stock les données, les classes JavaFX pour compiler Classe Séparée:Si le gestionnaire des constantes *Les méthodes d’une interface *toString() : donne le nom de la constante.
gérer le cycle de vie des applications JFX.
permet à la vue de lire son contenu et informe correctement le programme. d’événements est complexe, on peut le définir sont abstraites et publiques par défaut *values() : tableau de toutes les
javafx.stage:Gère les fenêtres et les dialogues
la vue d'éventuel motifs. ***Introduction aux Événements en JavaFX**** dans une classe séparée. C’est pratique si le *Une même classe peut implémenter plusieurs constantes→utilisable
de l'app.
La Vue, permet une représentation des En JavaFX, un événement est une action même code doit gérer plusieurs interfaces avec for‐each :
javafx.scene : scène graphique, qui contient
données. déclenchée par l'user ou le système, comme événements provenant de différentes sources Public interface I1{ void f(int n)//l’entête public for (Jour j : Jour.values()) {
les éléments visibles de l'interface.
Le Contrôleur, chargé de gérer les un clic de souris, .pression sur une touche... class MyHandler implements abstract est facultatif } System.out.println(j);}
javafx.scene.layout : Fournit des classes pour
interactions de l'utilisateur et de propager des JFX utilise 1 modèle de gestion d’events qui EventHandler<ActionEvent> { public void Public interface I2 void h() } Méthodes et champs dans enum
organiser et gérer la mise en page des
modifications vers la vue et le modèle. repose sur 3 éléments principaux. handle(ActionEvent e) { Class A implements I1,I2 { //définition les Un enum peut avoir des champs et des
composants.
***AWT (Abstract Window Toolkit):**** ***les events sont gérés via un systm de S.O.P("Bouton cliqué !");}} method f et h } méthodes :
(class)Stage : conteneur principal (fenêtre)
* 1er FrameWork d’interface graphique (GUI) délégation : button.setOnAction(new MonHandler()); *classe dérivée peut implémenter une enum Jour { LUNDI, MARDI, MERCREDI;
fourni au démarrage par JavaFX. C’est l’«
de Java. * Permet de créer des interfaces *Une source d'événement (ex. : un bouton) Chargé un fichier FXML : interface ou plusieurs void affiche() {
espace » qui accueille l’interface.(class)Scene
graphiques indépendantes de la plate‐forme . génère un événement.* l’event est transmis à FXMLLoader.load(getClass().getResource("int Public interface I { void f(int n) ; void(g) ; } System.out.println(this.toString ()); }}
: contient les éléments de
Limitations : *Support primitif et élémentaire un gestionnaire qui exécute une action erface.fxml")); Class A{…} for (Jour j : Jour.values()) { j.affiche() ;}
l’interface (boutons, textes, graphiques).
de la programmation GUI.*Ensemble de spécifique.*Le gestionnaire d’events traite ******contrôle de bouton******* Class B extends A implements I { …} *******annotations*******
**Noeuds et Graphe de Scène*****
contrôles limité par rapport aux standards l’event et libère la main. Un Button est un contrôle qui déclenche un Différences entre interface et classe abst : Une annotation est une marque associée à un
*Les éléments d'une scène sont appelés
actuels. **Avantages du système d'événements en ActionEvent quand on clique dessus. class abst peut contenir une implémentation élément (classe, méthode, champ…) pour
nœuds (Node).
*Tous les composants sont des composants JavaFX : Il peut afficher :un texte,une image, ou les de méthodes, de champs, de constructeurs ## fournir des métadonnées exploitables par :le
*Les nœuds peuvent être organisés en
lourds (dépendants des ressources natives du Flexibilité : Un même gestionnaire peut être lié deux. tandis compilateur,Les outils (ex. générateurs de
groupes (hiérarchie parent‐enfant).
à plusieurs éléments UI. Modularité :
code),L’exécution (via la réflexion) classes héritantes dont notamment les élément String titre; }); //Supprimer par indice
Annotations standards attributs utilisés pour par exemple trier une ListIterator<String> it = String auteur; } // Méthode pour rechercher une personne // marques.remove(2);
@Deprecated *Marque un élément comme telle collection. Ainsi c'est elle qui contient le liste.listIterator(liste.size()); public Document(String var1, String var2) { par son nom //Supprimer par condition
obsolète traitement de comparaison utilisé par while (it.hasPrevious()) {S.O.P(it.previous());} this.titre = var1; public static Personne //marques.removeIf((el)->el.length()<=4);
*Le compilateur génère un avertissement l'algorithme de tri. ***LinkedList*** this.auteur = var2; rechercherParNom(LinkedList<Personne> ///retainAll
*Signal : « N’utilisez plus cet élément, il existe la différence entre l'interface List et l'interface ‐‐Liste doublement chaînée.‐‐Permet des } liste, String nomRecherche) { marques.retainAll(Arrays.asList("AUDI"));
une meilleure alternative. » Collection est que l'interface List définit des parcours bidirectionnels avec ListIterator. public boolean equals(Object var1) { for (Personne p : liste) { /*List <String> newMarques = new
@Override *Indique qu’une méthode redéfinit méthodes supplémentaires basées sur la ‐‐Méthodes : addFirst(elem), addLast(elem), if (this == var1) { return true;} if LinkedList<>();
une méthode d’une superclasse notion d’ « index ». removeFirst(), removeLast(), remove(elem) else if (!(var1 instanceof Document)) { (p.getNom().equalsIgnoreCase(nomRecherche newMarques.add("RangeRover");
*Le compilateur :**Vérifie que la méthode > Concepts communs: Généricité Itérateur LinkedList<String> chaines = new return false;} )) { return p; newMarques.add("citroen");
existe bien, dans la superclasse **Génère une Ordonnancement Relation d’ordre LinkedList<>(); else { Document var2 = (Document)var1; }} marques.addAll(0, newMarques);
erreur si la signature ne correspond pas. *Généricité :Les collections utilisent des types chaines.addFirst("Fin"); return Objects.equals(this.titre, return null; // Pas trouvé //ContainsAll
Si la méth ne correspond pas, le compilateur génériques (<E>), ce qui veut dire qu’on peut Rappelons que la « position courante » var2.titre); } boolean cont =
le signale. préciser quel type d’objet sera stocké : utilisée par add est toujours définie: } public static void main(String[] args) { marques.containsAll(Arrays.asList("RangeRo
**Annotations personnalisées : L’utilisateur ( exemple ArrayList<String> liste = new Si la liste est vide ou si l’on n’a pas agit sur } LinkedList<Personne> listePersonnes = ver","Merc"));
peut définir ses propres annotations pour des ArrayList<>(); Cela empêche d’ajouter un l’itérateur, l’ajout se fera en début de liste, public abstract void AfficherDetails(); new LinkedList<>(); System.out.println("===========>"+cont);
traitementsspécifiques. objet d’un autre type (comme un Integer dans Si hasNext vaut false, l’ajout se fera en fin } // Ajout de personnes System.out.println("Apres addAll");
*****Programmation générique***** une liste de String).) de liste. public class Bibliotheque { listePersonnes.add(new for (String m:marques){
Permet d’écrire un code unique utilisable avec *Ordre et comparaison La classe LinkedList dispose de méthodes public static void main(String [] args){ Personne("Alice", 25)); System.out.println(m);
des objets de types différents, sans **Ordre naturel (Comparable) : Comparator spécifiques aux listes addFirst et addLast qui Document []doc = new Document[3]; listePersonnes.add(new Personne("Bob", 30)); }
duplication. est ici une interface qui contient la méthode ajoutent doc[0]= new Livre("Candide","Victor listePersonnes.add(new //Supprimer tout
Exemple : manipuler des objets sans void compare(T o1, T o2) qui est utilisée pour ***ArrayList*** Hiugo",378); Personne("Charlie", 20)); boolean removed
connaître leur type exact à l’avance. comparer les éléments de la collection ‐‐Tableau dynamique (accès rapide).‐‐Taille doc[1]= new Magazin("Prince","jean",50); System.out.println("Liste avant tri :"); =newMarques.removeAll(newMarques);
*Classe générique Certaines classes comme String, Integer ont ajustable dynamiquement.‐‐add(elem): ajoute for(Document d: doc){ for (Personne p : listePersonnes) { System.out.println(removed);
**Définie avec un paramètre de type (ex. T) : un ordre naturel. en fin de liste‐‐ add(index, elem): à une d.AfficherDetails(); p.afficher();} System.out.println("*****___________________
class Couple<T> { private T x, y; Elles implémentent l’interface Comparable position donnée‐‐ } // Tri par âge ******");
public Couple(T x, T y) { this.x = x; this.y = y;} avec la méthode compareTo() : remove(index): supprime par rang‐‐ // Méthode pour comparer deux boîtes trierParAge(listePersonnes); for (String m:marques){
public void affiche() { System.out.println(x + ", "a".compareTo("b") // → -1 (car "a" est avant remove(elem): public boolean comparer(Boite<T> // Affichage après tri System.out.println(m);
" + y);} "b") => On peut créer une classe : supprime par valeur‐‐removeRange(start, autreBoite) { System.out.println("\n aps tri par âge :"); }
public T getPremier() {return x;}} class Étudiant implements end): if (objet == null && autreBoite.getObjet() == for (Personne p : listePersonnes) { marques.sort(new Comparator<String>(){
T : représente un type quelconque (classe). Comparable<Étudiant> supprime plusieurs éléments consécutifs‐‐ null) { return true; p.afficher(); @Override
À l’instanciation, on précise le type effectif : {String nom;int note; get(index), } else if (objet != null) { } public int compare( String s1 ,String s2){
Couple<Integer> c = new Couple<>(1, 2); Étudiant(String n,int note){this.nom = set(index, elem): accès / modification directe return objet.equals(autreBoite.getObjet()); // Recherche par nom //-1 s1 9bel s2 //0 s1=== s2 // 1 s1 mor s2
c.affiche(); n;this.note =note;} ArrayList<String> couleurs = new } else { return false; String nomRe = "Bob"; return s1.compareTo(s2);
Integer premier = c.getPremier(); public int compareTo(Étudiant e) {return ArrayList<>(); } } Personne resultat = }
** Les types primitifs (ex. int) doivent être this.note ‐ couleurs.add("Vert"); couleurs.set(0, "Bleu"); //Dans le main rechercherParNom(listePersonnes, nomRe); });
remplacéspar leur wrapper (ex. Integer). e.note; // ordre croissant}} ***HashSet et TreeSet*** public class TestBoite { if (resultat != null) { Collections.sort(names, new Comparator(){
*********Collections************ **Ordre personnalisé (Comparator) Aucun doublon autorisé.*HashSet : non public static void main(String []args){ System.out.println("\nPersonne @Override
Si on veut changer l’ordre de tri, on peut créer ordonné Boite <Integer> bInt=new Boite trouvée :"); public int compare(String s1,String s2){
un objet Comparator. TreeSet : trié selon l’ordre naturel <Integer>(23); resultat.afficher(); return s1.compareTo(s2);
import java.util.*; (Comparable) ou un Boite<Integer> bInt1=new Boite } else { }
Comparator<Étudiant> parNom = new Comparator *add(elem) : ajoute si l’élément <Integer>( 23); System.out.println("\nPersonne });
Comparator<>() { n’est pas Boite <String> bString=new Boite nommée " + nomRe + " non trouvée."); ///clear suuprimer tout les elements
public int compare(Étudiant e1, Étudiant e2) { déjà présent *remove(elem) : supprime un <String>("khaoula"); }}} marques.clear();
Elles font partie du package java.util et return e1.nom.compareTo(e2.nom);}}; Boite <Double> bDouble= new Boite import java. util.ArrayList;import System.out.println("la taille de la liste
élément
permettent d'utiliser différentes structures de ***Itérateurs*** Un itérateur : Objet permet de <Double>(2.0); java.util.Arrays; import java.util.LinkedList; ="+marques.size());
donné
données, comme : *Listes (ex. : suite parcourir les éléments d’une collection un par bInt.afficherObjet(); import java.util.List;import }
*iterator():pour parcourir les éléments
ordonnée d’éléments)*Vecteurs dynamiques un. => Iterator (monodirectionnel) hasNext():y bString.afficherObjet(); java.util.Comparator; }
(monodirectionnel uniquement)
(tableaux ajustables)*Ensembles (pas de bDouble.afficherObjet(); public class Main { //Calculatrice
a‐t‐il un élément suivant ? *next() : retourne HashSet<String> set = new HashSet<>();
doublons)*Queues (files d’attente)*Tables if(bInt.comparer(bInt1)){ public static void main(String [] args){ import javafx.application.Application;
l’élément suivant *remove() : supprime le set.add("a");
associatives (paires clé/valeur → comme un System.out.println("sont identiques"); ArrayList <String> marques = new import javafx.scene.Scene;
dernier élément visité Méthodes pour les Set :
dictionnaire } ArrayList <String> (); import javafx.scene.control.Button;
ArrayList<String> liste=new isEmpty():retourne true si le set est vide
Le polymorphisme d'une collection signifie else{ marques.add("Mercedes"); import javafx.scene.control.Label;
ArrayList<>(List.of("a","b")); *containsAll(bib2):vérifier si le set contient
plutôt que System.out.println("sont differents"); marques.add("AUDI"); import javafx.scene.control.TextField;
Iterator<String> it = liste.iterator(); tous les
Une collection peut stocker des références }}} marques.add("DACIA"); import javafx.scene.layout.GridPane;
while (it.hasNext()) {S.O.P(it.next());} éléments d’un autre set
d'un type parent mais contenir des objets import java.util.*; // marques.set(2,"hassan"); import javafx.scene.layout.VBox;
// Récupération de l'iterator *retainAll(bib2):intersection
d'une ou plusieurs classes filles différentes. EXO3 //contains pour chercher import javafx.stage.Stage;
Iterator<String> it = fruits.iterator(); entre les deux sets (garde les communs)*
Expliquez le rôle d'une classe abstraite dans public class Main { boolean isThere = public class Main extends Application {
// Parcours de la liste avec l'iterator removeAll(bib2):différence (supprime les
la conception d'une collection polymoprhe. // Méthode pour trier la liste par âge marques.contains("Mercedes"); private double nombre1, nombre2, resultat;
while(it.hasNext()) { // tant qu'il y a un éléments
Dans une collection polymorphe, la classe public static void System.out.println(isThere); private TextField textField;
élément suivant communs avec bib2)
abstraite est le type de l'élément de la trierParAge(LinkedList<Personne> liste) { //indexOf,Lindex ou la positiondyal l'objet private Label result;
String fruit = it.next(); // récupérer ***Méthodes valables pour toutes les
collection. Elle contient des méthodes Collections.sort(liste, new int indice = private GridPane root;
l'élément suivant collections :
abstraites implémentées par les classes Comparator<Personne>() { @Override marques.indexOf("RangeRover"); @Override
System.out.println(fruit); addAll(c): union retainAll(c): intersection
héritantes ce qui permet à une classe qui public int compare(Personne p1, Personne /* System.out.println(indice); public void start(Stage primaryStage) {
=>ListIterator (bidirectionnel) Utilisé pour des removeAll(c): différence
utilise une telle collection de créer des p2) { //supprimer [par objet] root = new GridPane();
collections comme LinkedList ou ArrayList : ackage Exercice1;
traitements génériques sur tous les types qui return Integer.compare(p1.getAge(), //boolean isRemoved = textField = new TextField();
‐‐next() / previous() : aller en avant ou en import java.util.Objects;
héritent de cette classe abstraite. Elle contient p2.getAge()); marques.remove("hassan"); result = new Label("0.0");
arrière abstract class Document {
bien sur tous les attributs communs aux } //System.out.println(isRemoved); int row = 0;
‐‐add() / set():ajouter un elem / remplacer un
 int column = 0; public class FormulaireAvecBDD extends VBox root = new VBox(15, ligneNom, combo.setOnAction(e ->
String[] buttons = { Application { lignePrenom, ligneAge, lignePassword, System.out.println(combo.getValue()));
"7", "8", "9", "/", "4", "5", "6", "*", "1", private Connection connect() { ligneBoutons); CheckBox cb = new CheckBox("J'accepte");
"2", "3", "-", "C", "0", "=", "+" }; // SQLite connection root.setPadding(new Insets(20)); -----------------------------
for (String btnTe : buttons) { String url = "jdbc:sqlite:utilisateur.db"; root.setPrefWidth(350); btn1.setOnAction(unHandler);
Button btn = new Button(btnTe); Connection conn = null; // Action des boutons btn2.setOnAction(unHandler);
root.add(btn, column, row); try { btnAjouter.setOnAction(e -> { EventHandler<ActionEvent> unHandler =
btn.setMinSize(50, 50); conn = DriverManager.getConnection(url); try { event -> {
column++; } catch (SQLException e) { String nom = fieldNom.getText(); Object src = event.getSource();
if (column > 3) { System.out.println(e.getMessage()); } String prenom = fieldPrenom.getText(); if (src == btn1) { // Traitement pour btn1
} else if (src == btn2) {// Traitement pour
column = 0; return conn; int age = Integer.parseInt(fieldAge.getText());
btn2}};
row++; } String password = fieldPassword.getText();
Avantages de MVC ,Structure ‘propre’ de
} private void insertUtilisateur(String nom, insertUtilisateur(nom, prenom,age,password); l’application Indépendance ‘données’ –
btn.setOnAction(event -> String prenom, int age, String password) { Alert alert = new ‘représentation’ – ‘comportements’ ,Adapté
ButtonAction(btn.getText())); String sql = "INSERT INTO utilisateur(nom, Alert(Alert.AlertType.INFORMATION, aux concepts de la programmation 0-
} prenom, age, password) VALUES(?,?,?,?)"; "Utilisateur ajouté avec succès !"); 0Modulaire et réutilisable ,Vues
VBox vbox = new VBox(); try (Connection conn = this.connect(); alert.showAndWait(); interchangeables
vbox.getChildren().addAll(textField, PreparedStatement pstmt = // Reset des champs après ajout Contrôleurs interchangeables, Changement
result, root); conn.prepareStatement(sql)) { fieldNom.clear(); de ‘Look & Feel’
Scene scene = new Scene(vbox, 250, pstmt.setString(1, nom); fieldPrenom.clear(); Facilite les vues et contrôleurs multiples,
300); pstmt.setString(2, prenom); fieldAge.clear(); Synchronisation ‘quasi-implicite
primaryStage.setTitle("Calculatrice pstmt.setInt(3, age); fieldPassword.clear(); Inconvénients de MVC
JavaFX"); pstmt.setString(4, password); } catch (NumberFormatException ex) { Mise en place complexe dans le cas
d’applications importantes
primaryStage.setScene(scene); pstmt.executeUpdate(); Alert alert = new
Mises à jour potentiellement trop nombreuses
primaryStage.show(); System.out.println("Utilisateur inséré Alert(Alert.AlertType.ERROR, "Veuillez saisir Temps d’exécution ,Contrôleur et Vue restent
} avec succès !"); un âge valide."); souvent fortement liés au Modèle
private void operation(String text) { } catch (SQLException e) { alert.showAndWait(); Adapter la réalisation au problème
String[] parties = text.split("[+\\-*/]"); System.out.println(e.getMessage());}} } });
if (parties.length < 2) { ///Formulaire btnFermer.setOnAction(e ->
result.setText("Erreur"); public class FormulaireApp extends primaryStage.close());
return; Application { Scene scene = new Scene(root);
} @Override primaryStage.setTitle("Formulaire JavaFX
try { public void start(Stage primaryStage) { + SQLite");
nombre1 = // Création des labels et champs primaryStage.setScene(scene);
Double.parseDouble(parties[0]); Label labelNom = new Label("Nom:"); primaryStage.show();
nombre2 = TextField fieldNom = new TextField(); }}
Double.parseDouble(parties[1]); Label labelPrenom = new public static void main(String[] args) {
} catch (NumberFormatException e) { Label("Prénom:"); launch(args);
textField.setText("Erreur de format"); TextField fieldPrenom = new TextField(); }
return; Label labelAge = new Label("Âge:"); }
} TextField fieldAge = new TextField();\ 2. TextField + PasswordField + Button :
String operateur = text.replaceAll("[0-9.]", Label labelPassword = new Label("Mot de:"); TextField tf = new TextField();
""); PasswordField fieldPassword = new PasswordField pf = new PasswordField();
resultat = 0; PasswordField(); Button btn = new Button("Valider");
switch (operateur) { // Boutons btn.setOnAction(e ->
case "+" : resultat = nombre1 + nombre2; brk; Button btnAjouter = new Button("Ajouter"); System.out.println(tf.getText() + " " +
case "-": resultat = nombre1 - nombre2 ; brk; Button btnFermer = new Button("Fermer"); pf.getText()));
case "*" : resultat = nombre1 * nombre2 ;brk; // Layout pour chaque ligne (label + champ) ////////////////
case "/": if (nombre2 != 0) HBox ligneNom = new HBox(10, labelNom, TextField tf = new TextField();
resultat = nombre1 / nombre2; fieldNom); PasswordField pf = new PasswordField();
else HBox lignePrenom = new HBox(10, Label label = new Label();
textField.setText("Division par zéro !") ; labelPrenom, fieldPrenom); Button btn = new Button("Valider");
brk; HBox ligneAge = new HBox(10, labelAge, btn.setOnAction(new
default : result.setText("Erreur"); fieldAge); EventHandler<ActionEvent>() {
return ; } HBox lignePassword = new HBox(10, @Override
result.setText(String.valueOf(resultat)); } labelPassword, fieldPassword); public void handle(ActionEvent event) {
private void ButtonAction(String btn) { // Alignement des lignes label.setText("Welcome Mr " +
switch (btn) { ligneNom.setAlignment(Pos.CENTER_LEFT); tf.getText());
case "=": operation(textField.getText()); lignePrenom.setAlignment(Pos.CENTER_LET) }
break; ligneAge.setAlignment(Pos.CENTER_LEFT); });
case "C": textField.clear(); lignePassword.setAlignment(Pos.CENTER_LE TableColumn<Person, String> colNom = new
result.setText("0.0"); FT); TableColumn<>("Nom");
break; // Ligne des boutons colNom.setCellValueFactory(new
default: textField.setText(textField.getText() + HBox ligneBoutons = new HBox(20, PropertyValueFactory<>("nom"));
btn) ; break;}} btnAjouter, btnFermer); ComboBox<String> combo = new
public static void main(String[] args) { ligneBoutons.setAlignment(Pos.CENTER); ComboBox<>();
launch(args);}} // Conteneur principal vertical combo.getItems().addAll("Java", "Python");