IHM :Interface Homme – Machine**Interactions *Extension de AWT, offrant des composants ***Note : Les System.out.

***Note : Les System.out.println sont juste pour sources (comme plusieurs boutons). if (cbKeyboard.isSelected())response.setText("Clavier
Homme – Machine**Dialogue Homme – Machine graphiques plus riches et plus flexibles. montrer l'ordre d'appel des méthodes. class MyHandler implements sélectionné.");
L’interface homme machine ‐ est un ensemble de *Caractéristiques principales : ****Commande de compilation**** EventHandler<ActionEvent> { else response.setText("Clavier désélectionné.");
dispositifs matériels et logiciels permettant de **Composants légers : Swing ne dépend pas des javac ‐‐module‐path "C:\javafx‐sdk‐23.0.1\lib" ‐‐add‐ public void handle(ActionEvent e) { showAll();});
contrôler et de communiquer avec une machine. composants graphiques natifs, les éléments sont modules javafx.controls JavaFXSkel.java S.O.P("Bouton cliqué !");}} cbMouse.setOnAction(new
L’interaction homme machine ‐ est une action qui dessinés par le moteur graphique Java. --module-path:indique où sont les fichiers.jar de JavaFX. button.setOnAction(new MonHandler()); EventHandler<ActionEvent>() {
provoque une réaction perceptible. Elle **Pluggable look and feel : possibilité de changer --add-modules javafx.controls : ajoute les modules ******contrôle de bouton******* public void handle(ActionEvent ae)
regroupe des notions telles que les clics souris, la frappe dynamiquement l'apparence des interfaces pour imiter nécessaires pour les contrôles graphiques. Un Button est un contrôle qui déclenche un ActionEvent {if (cbMouse.isSelected())
de touches, les pressions sur un écran différents styles (Windows, macOS, Metal, etc.). But :Assurer que le compilateur trouve toutes les classes quand on clique dessus. response.setText("Souris sélectionnée.");
tactile, etc. **Cohérence multiplateforme : même apparence et JavaFX pour compiler correctement le programme. Il peut afficher :un texte,une image,ou les deux. else response.setText("Souris désélectionnée.");
Le dialogue Homme Machine ‐ est l'ensemble des même comportement sur toutes les plateformes. ***Introduction aux Événements en JavaFX**** 📌 Constructeurs buton showAll(); }});
échanges entre un utilisateur et une machine. *Avantages sur AWT : En JavaFX, un événement est une action déclenchée Button() → bouton vide.*Button(String texte) → bouton cbTouchScreen.setOnAction(new
Ces échanges regroupent les manipulations avec un **Composants plus personnalisables. par l'user ou le système, comme un clic de souris, avec texte.*Button(String texte, Node image) → bouton EventHandler<ActionEvent>() { public void
écran tactile, l’utilisation d'un microphone, **Interfaces plus cohérentes d'une plateforme à l'autre. .pression sur une touche... JFX utilise 1 modèle de avec texte et image. handle(ActionEvent ae) {
d'un scanner, d'une table à digitaliser, etc. Gestion améliorée des interfaces utilisateur pour les gestion d’events qui repose sur 3 éléments principaux. Gestion d’events utiliser :button.setOnAction(handler); if (cbTouchScreen.isSelected()) response.setText("Écran
Les interfaces utilisateur GUI qui intègre ces élément applications modernes. ***les events sont gérés via un systm de délégation : Tactile sélectionné.");
graphique sont parfois désignées par l'acronyme WIMP: ********javaFX****** *Une source d'événement (ex. : un bouton) génère un else response.setText("Écran Tactile désélectionné.");
Window : Notion de "fenêtre" (zone d'interaction Caractéristiques : événement.* l’event est transmis à un gestionnaire qui showAll();}});
indépendante) ************Nœuds JavaFX*********** exécute une action spécifique.*Le gestionnaire d’events // Ajouter les contrôles à la scène
Contrôles Modernes *Graphique de Scène
Icon : Éléments graphiques visuels (images, boutons, Tous les nœuds héritent de la classe Node, qui permet traite l’event et libère la main. rootNode.getChildren().addAll(heading, cbKeyboard,
*Architecture MVC *Déploiement Simplifié
champs de texte, bulles d'aide, etc.) de:*positionner, translater, tourner un nœud*définir **Avantages du système d'événements en JavaFX : cbMouse, cbTouchScreen, response, selected);
Support CSS et FXML.
Menu : Choix d'actions parmi une liste proposée son style(opacité…)*attacher des gestionnaires d’events Flexibilité : Un même gestionnaire peut être lié à myStage.show();}
⚡ JavaFX : création des interfaces
Pointer : Curseur/Pointeur manipulé par la souris, et qui ***Catégories principales plusieurs éléments UI. Modularité : Séparation entre // Mese à jour et afficher la liste dispositifs sélectionnés
➡ Manière déclarative Nœuds géométriques (héritent de Shape) :
permet d'interagir avec les composants visuels. l’interface graphique et la gestion des événements. void showAll() { inputDevices = "";
*Interface décrite en FXML (XML). Formes simples : Arc, Circle, Ellipse, Line, Polygo..
JavaFX est une collection de classe,d'interface qui définit Réutilisation : Un gestionnaire peut être réutilisé dans if (cbKeyboard.isSelected()) inputDevices += "Clavier ";
*Création facilitée par SceneBuilder. Courbes : CubicCurve, QuadCurve
l'interface graphique utilisateur (GUI) moderne de Java. plusieurs parties de l’application. if (cbMouse.isSelected()) inputDevices += "Souris ";
*Bonne séparation présentation / logique (MVC). Chemins : Path, SVGPath
JavaFX simplifie la création d'une application en if (cbTouchScreen.isSelected()) inputDevices += "Écran
facilitant la gestion de ses eléments GUI et le ➡ Manière procédurale Texte : Text Tactile ";
déploiement de l'application. *Interface construite par code Java (API). Nœuds graphiques :ImageView (image) ;MediaView if (inputDevices.equals("")) inputDevices = "<aucun>";
Composants lourds:composants liés à la plate‐forme *Plus flexible : création dynamique, extensions (vidéo) ;Canvas (dessin modifiable) selected.setText("Dispositifs supportés : "
locale d'exécution, car ils sont implémentés en code possibles. Nœuds de contrôle :Composants interactifs (Button, +inputDevices);}}
natif du SE hôte et la Java Machine y fait appel lors de Les 2 method peuv être combinées grâce à javafx.fxml Menu, etc.) ;Tous héritent de Control héritant **********CSS ET JAVAFX*********
l'interprétation du prog Java. Une application JavaFX peut être installé : localement (indirectement) de Node. CSS via le package javafx.css.
Le composant soit défini comme un objet Java dans le ou sur un serveur et intégrée dans une page web ***JavaFX : Classe Application et cycle de vie*** JavaFX utilise un style par défaut appelé modena.css,
code, lorsqu'il est exécuté sur une *****Structure des Paquets :*** Une application JavaFX hérite de Application (package intégré dans le runtime JavaFX.
plateforme spécifique il est lié à un équivalent local dans Le framework JavaFX est organisé en plus de 30 paquets javafx.application). Style.css par exemple : .button {
L SE , appelé "peer". Ce peer est la version native du qui commencent par le préfixe javafx. Exemples : ***Méthodes du cycle de vie : ‐fx‐background‐color: #3498db;
composant, adaptée à l'apparence et au javafx.application : Contient des classes pour gérer le init():Appelée en 1er Sert aux initialisations (pas de ‐fx‐text‐fill: white;
cycle de vie des applications JavaFX. création de scène/stage).*Surcharge optionnelle *** controle de CheckBox en JavaFX***
comportement de l'interface user de cette plateforme. ‐fx‐font‐size: 14px;}
javafx.stage:Gère les fenêtres et les dialogues de l'app. (implémentation vide par défaut). Superclasse : ButtonBase
Composants légers:comme ceux de la bib Swing, sont Ou dans le code java :
javafx.scene : scène graphique, qui contient les start(Stage primaryStage)Appelée après init(). Fonction:Représent une case à coche(bouton avec état).
entièrement implémentés en Java, ce qui les rend Scene scene = new Scene(root, 400, 300);
États possibles*Checked *Unchecked
indépendants du système d'exploitation sous‐jacent, : éléments visibles de l'interface. *Obligatoire : méthode abstraite, doit la surcharger. scene.getStylesheets().add(getClass().getResource("style
javafx.scene.layout : Fournit des classes pour organiser *Sert à créer et afficher la scène principale. *Indeterminate : état intermédiaire (à activer avec
 Indépendance des Peers s.css").toExternalForm());
et gérer la mise en page des composants. stop():Appelée à la fin de l’application.*Sert aux tâches ‐ setAllowIndeterminate(true))
 Dessin en Java ****TP1 exo 1********
(class)Stage : conteneur principal (fenêtre) fourni au de nettoyage.*Surcharge optionnelle (implémentation Classe Event : La classe de base des événements JavaFX Constructeurs :*CheckBox() : sans texte.
 Portabilité abstract class Document {protected String titre ;
démarrage par JavaFX. C’est l’« espace » qui accueille vide par défaut). : javafx.event.Event. *CheckBox(String text) : avec texte (étiquette).
 Look and Feel :changer l'apparence de l'interface protected String auteur ;
l’interface.(class)Scene : contient les éléments de *Lancement de l'application launch(args) : Rôle: Encapsulation des infos sur un event (source, Gestion des événementsUtilise setOnAction() pour
L’architecture de type MVC est une architecture qui public Document (String titre , String auteur){
l’interface (boutons, textes, graphiques). Démarre l'application.*Crée une instance de sous‐classe type....Chaque event représenté par un objet Event. définir un gestionnaire quand la case est cliquée.
sépare le stockage des données, leur représentation et this.titre=titre;this.auteur=auteur;
*Chaque application JavaFX a au moins un Stage et une Application.*Appel dans l'ordre : init(), start(). Méthodes Utiles : La classe Event propose des Obtenir l’état :*isSelected() : retourne true si cochée,
les interactions possibles avec les données, les public abstract void afficherDetails() ;
Scene.**La Scene est définie sur un Stage pour afficher *Reste active jsq'à la fermeture de l'app (ensuite stop()). méthodes pour obtenir des détails sur l'événement, sinon false.*isIndeterminate() : retourne true si
composants sont associés à différentes interfaces de @Override public boolean equals(Object obj) {
le contenu.**autres stages peuvent être créés si besoin. main() :Appelle launch(args).*Pas strictement comme getSource() getEventType(). indéterminée.
modèles de base : if (this == obj) return true;
**Noeuds et Graphe de Scène***** obligatoire, mais recommandé pour compatibilité. Sous-classes courantes : ActionEvent : événements ******exemple CheckBox *******
Le Modèle chargé de stock les donnés, permet à la vue if (!(obj instanceof Document)) return false;
*Les éléments d'une scène ****Squelette d'une Application JavaFX**** d'action (ex. clic sur un bouton)*MouseEvent : actions import javafx.application.*; javafx.scene.*;
de lire son contenu et informe la vue d'éventuel modifs. Document document = (Document) obj;
sont appelés nœuds (Node). de la souris (clic, déplacement...)*KeyEvent : actions du javafx.stage.*; javafx.scene.layout.*;
La Vue, permet une représentation des données. return Objects.equals(titre, document.titre);}}
*Les nœuds peuvent être clavier (touche pressée...) javafx.scene.control.*;javafx.geometry.*;
Le Contrôleur, chargé de gérer les interactions de class Livre extends Document {
organisés en groupes **setOnKeyPressed() :*capte l'appui sur une touche et javafx.event.*;
l'utilisateur et de propager des modifications private int nombrePages ;
(hiérarchie parent‐enfant). affiche son code dans la console.. Exple syntaxe: public class CheckBoxDemo extends Application {
vers la vue et le modèle. public Livre (int nombrePages, String auteur , String
*Les nœuds sans enfants = scene.setOnKeyPressed(event -> { CheckBox cbKeyboard; CheckBox cbMouse;
***AWT (Abstract Window Toolkit):**** titre){
feuilles ; *un parent peut avoir plusieurs enfants. S.o.P ("Code de la touche : " + event.getCode())}); CheckBox cbTouchScreen;
*1er framework d’interface graphique (GUI) de Java. super(auteur,titre); nombrePages=this.nombrePages;}
*L’ensemble forme un graphe de scène sous forme *****EventHandler****** Label response; // Label pour afficher la réponse
*Permet de créer des interfaces graphiques @Override public void afficherDetails(){
d’arbre, avec un nœud racine (sans parent). Un EventHandler en JavaFX est une interface qui sert à Label selected; // Label afficher dispositifs sélectionnés
indépendantes de la plate‐forme .
S .O.P("livre "+titre + "auteur " +auteur+" nombre de
*Tous les nœuds dérivent de la classe Node ; exemples : réagir aux événements (clics, frappes clavier, etc.). String inputDevices = ""; //pour stocker les dispositifs
pages "+nombrePages );}}
*Les composants graphiques utilisent les capacités Parent, Group, Region, Control. d'entrée sélectionnés
Quand un event se produit, JavaFX appelle la méthode class Magazine extends Document {
graphiques natives du SE. ***Dispositions (Layouts) en JavaFX****** handle() de l’EventHandler pour exécuter une action. public static void main(String[] args) {launch(args);}
protected int numeroEdition ;
*Propose des classes pour : Les panneaux de disposition gèrent le placement des void handle(T event); @Override public void start(Stage myStage) {
public Magazine(int numeroEdition, String auteur,String
**composants de base (boutons, fenêtres…) éléments dans une scène.Exemples : myStage.setTitle("Démonstration des Cases à Cocher");
***Implémenter un EventHandler titre){
**polices, couleurs, images FlowPane : organise les éléments en flux (séquentiel). FlowPane rootNode=new
Classe Anonyme:créer le EventHandler directement super(titre,auteur); numeroEdition=this.numeroEdition;}
Limitations : *Suport primitif et élémentaire de la GridPane : disposition en grille (lignes/colonnes). FlowPane(Orientation.VERTICAL, 0, 10);
dans le code, sans faire de classe séparée. Cela rend le @Override public void afficherDetails(){
rootNode.setAlignment(Pos.CENTER_LEFT);
programmatio GUI.*Ensemble de contrôles limité par BorderPane : zones : haut, bas, gauche, droite, centre. code + court mais peut être moins clair. S.O.P("magazine "+titre+" auteur "+auteur+"
Tous les panneaux héritent de Node. rootNode.setPadding(new Insets(0, 0, 0, 10));
rapport aux standards actuels. button.setOnAction(new EventHandler<ActionEvent>() numeroEdition "+numeroEdition);}}
Ils se trouvent dans le package javafx.scene.layout. Scene myScene = new Scene(rootNode, 300, 180);
*Tous les composants sont des composants lourds {public void handle(ActionEvent e) { public class Biblio {
myStage.setScene(myScene);
(dépendants des ressources natives du système). System.out.println("Bouton cliqué !");}}); public static void main( String[]args){
Label heading=new Label("Sélectio les Dispositifs
Les deux classes principales : *Component : classe de Expression Lambda:est une façon rapide de créer des Document[] doc=new Document[4];
d'Entrée");
base pour tous les objets graphiques (boutons, champs méthodes.Elle rend le code très concis, surtout pour de doc[0]=new Livre(20,"lamyae","petit") ;
response = new Label("Aucun dispositif sélectionné");
petits EventHandler. doc[1]=new Livre(30,"iman","fille");
de texte, fenêtres…)*Container : sous‐classe de compile : javac --module-path "C:\javafx-sdk- selected = new Label("Dispositifs supportés : <aucun>");
button.setOnAction(e ‐> S.O.P("Bouton cliqué !")); doc[2]=new Magazine(3, "fatima", "belle ville");
Component qui peut contenir d’autres 23.0.1\lib" --add-modules javafx.controls cbKeyboard = new CheckBox("Clavier");
Classe Séparée:Si le gestionnaire d’événements est doc[3]=new Magazine(4,"noura","foot");
composants(fenêtre principale, panneau) JavaFXSkel.java cbMouse = new CheckBox("Souris");
complexe, on peut le définir dans une classe séparée. for (Document documents:doc)
*****************Swing********* Lance : java --module-path "C:\javafx-sdk-23.0.1\lib" -- cbTouchScreen = new CheckBox("Écran Tactile");
C’est pratique si le même code doit gérer plusieurs { documents.afficherDetails();}}
*Introduit en 1997, initialement comme librairie séparée add-modules javafx.controls JavaFXSkel cbKeyboard.setOnAction( new EventHandler
événements provenant de différentes *****TP1 EXO2 ENUM*****
pour Java 1.1, puis intégré dès Java 1.2. Figure : Graphe de scène et son apparence à l'écran <ActionEvent>() {public void handle(ActionEvent ae) {
enum Departement {INFO , RH, FINANCE , MARKETING}; public static void afficherListe(LinkedList<Personne> button.setOnMouseExited(e ‐> button.setStyle("‐fx‐ Déballage (unboxing)Conversion d’un objet => Concepts communs :
public abstract class Employee implements Promotable liste) {for Personne p : liste) {p.afficher();}} background‐color:#E3A5C7;"));}}} wrapper→type primitif. *Généricité :Les collections utilisent des types
{protected String nom,prenom ; public static void trierParAge(LinkedList<Personne> root.getChildren().addAll(label, buttons); int n = nObj; // équivalent à nObj.intValue() génériques (<E>), ce qui veut dire qu’on peut préciser
protected double salaire; protected Departement dep; liste) {Collections.sort(liste);} Scene scene = new Scene(root, 330, 440); *****enumeration**** quel type d’objet sera stocké :
Employee(String nom, String prenom , double salaire, public static Personne rechercherParNom scene.getStylesheets().add(getClass().getResource("style Définition :Un type énuméré (enum) définit un ( exemple ArrayList<String> liste = new ArrayList<>();
Departement dep){this.nom=nom;this.prenom=prenom; (LinkedList<Personne> liste, String nom) {for (Personne .css").toExternalForm()); ensemble fini de constantes.Exemple : Cela empêche d’ajouter un objet d’un autre type
this.salaire=salaire;this.dep=dep;} p : liste) { if (p.getNom().equalsIgnoreCase(nom)) { stage.setTitle("Calculator"); stage.getIcons().add(icon); enum Jour {LUNDI, MARDI, MERCREDI, JEUDI, (comme un Integer dans une liste de String).)
abstract double calulerBonus(); return p;}} return null;}} stage.setResizable(false); stage.setScene(scene); Methode equals : Il compare les @de deux object VENDREDI, SAMEDI, DIMANCHE} *Ordre et comparaison
public void augmenterSalaire(double pourcentage) { ******TP3Manipulation de ArrayList******* stage.show();} concernés Jour est une classe dérivée de Enum. **Ordre naturel (Comparable) :Certaines classes
salaire += salaire * pourcentage / 100;}} public class Main { private void handleButtonClick(String text) { boolean equals{Point p){ return (p.x=x)&&(p.y=y);}} Utilisation : comme String, Integer ont un ordre naturel.
public class Devloppeur extends Employee{ public static void main(String[] args) { if ("1234567890".contains(text)) {currentInput += text; Types de classes/Interface: *Déclaration d’une variable : Jour courant = Jour.MARDI; Elles implémentent l’interface Comparable avec la
public Devloppeur(String nom,String prenom, double ArrayList<String> paysNom = new ArrayList<String>(); label.setText(currentInput);} # class et methode finales : *Var final = cte Il faut toujours préfixer par le nom de l'énumération méthode compareTo() :
salaire,Departement dep ) paysNom.add("Maroc");paysNom.add("France"); else if ("C".equals(text)) {currentInput = ""; *Metho final = ne peut pas etre redefinie (ex. Jour.MARDI). "a".compareTo("b") // → -1 (car "a" est avant "b")
{super(nom,prenom,salaire,dep );} paysNom.add("Espagne");paysNom.add("Italie"); label.setText("0");} *Class final = ne peut être dérivée Comparaison => On peut créer une classe :
public double calulerBonus(){ return salaire*0.1 ; }} paysNom.add("Alemagne");paysNom.add("Angleterre"); else if ("=".equals(text)) {try { *Class non final + tous les methode final = class non final *Égalité : if (courant == Jour.MARDI) { ... } class Étudiant implements Comparable<Étudiant>
public class Manager extends Employee{//constructeur //affichege double result = eval(currentInput); # class abstraites : *Ordre : {String nom;int note;
public double calulerBonus(){return salaire*0.2 ; }} S.O.P("PAYS : " + paysNom); label.setText(String.valueOf(result)); *Class abst = ne permet pas d’instancier un objet courant.compareTo(Jour.LUNDI); // basé sur l'ordre de Étudiant(String n,int note){this.nom = n;this.note =note;}
public interface Promotable { S .O.P("Le premier pay: " + paysNom.get(0)); currentInput = "";} catch (Exception e) { *Methode abst = doit etre redefinie + contient que des *déclaration : Rang : courant.ordinal(); public int compareTo(Étudiant e) {return this.note ‐
public void augmenterSalaire(double pourcentage);} S.O.P("dernier pay :"+paysNom.get(paysNom.size() ‐ 1)); label.setText("Erreur");currentInput = "";}} signatures que l’ntete //ex:MERCREDI.ordinal() vaut 2 e.note; // ordre croissant}}
public class Societe {public static void main(String[] args) //modification else {currentInput += " " + text + " "; =>Regles : Avec switch **Ordre personnalisé (Comparator)
{Employee[] Em = new Employee[2]; paysNom.set(1, "Angleterre");paysNom.remove(2); label.setText(currentInput);}}private double eval(String *class contient une ou plusieurs meth abst = class abst switch (courant) { case LUNDI:// ... break; Si on veut changer l’ordre de tri, on peut créer un objet
Em[0] = new Devloppeur("lamyae", "GI", 2000, //tri et recherche currentInput) {String[] tokens = currentInput.split(" "); (meme si on pas ecrit le mot abs) case MARDI:// ...break;} Comparator.
Departement.INFORMATIQUE); Collections.sort(paysNom); double a = Double.parseDouble(tokens[0]); *methode abst est oblig public Conversion et itération import java.util.*;
Em[3] = new Manager("amina", "dahbi", 4500, S.O.P ("Les pays sont : " + paysNom); String operator = tokens[1]; *Une class dérivée d’une classe non abs peut être *toString() : donne le nom de la constante. Comparator<Étudiant> parNom = new Comparator<>() {
Departement.MARKETING); S.O.P(paysNom.contains("Maroc")); double b = Double.parseDouble(tokens[2]); déclarée abst et/ou contenir des métho abstraites *values() : tableau de toutes les constantes→utilisable public int compare(Étudiant e1, Étudiant e2) {
for (int i = 0; i < 4; i++) {Em[i].augmenterSalaire(10); *********TpUtilisation de HashSet**** return switch (operator) {case "+" ‐> a + b; case"‐”‐>a‐ b; * Une classe abstraite peut comporter un ou plusieurs avec for‐each : return e1.nom.compareTo(e2.nom);}};
S.O.P("Nom: " + Em[i].nom+ " Prenom: " +Em[i].prenom HashSet<Integer> numbersSet = new case "*" ‐> a * b;case "/" ‐> a / b; constructeurs, mais ils ne peuvent pas être abstrait for (Jour j : Jour.values()) { System.out.println(j);} ***Itérateurs*** Un itérateur permet de parcourir les
+" Salaire: " + Em[i].salaire+" Département: " + HashSet<Integer>(); default ‐> throw new *dans une class abst A : Méthodes et champs dans enum éléments d’une collection un par un.
Em[i].dep); S.O.P("Bonus après augmentation: " numbersSet.add(10);numbersSet.add(20); IllegalArgumentException("Opération invalide: " + ‐On peut faire : A a ; // oui a une ref sur un objet de Un enum peut avoir des champs et des méthodes : => Iterator (monodirectionnel)
Em[i].calulerBonus());}}} numbersSet.add(30);numbersSet.add(40); operator);};}} type A ou derive enum Jour { hasNext():y a‐t‐il un élément suivant ? *next() : retourne
*******TP prog GENERIQUE********* numbersSet.add(10);numbersSet.add(20); ********Mot de passe****** ‐Mais pas : a = new A(…) //erreur pas d instance On LUNDI, MARDI, MERCREDI; l’élément suivant *remove() : supprime le dernier
class Boite<T>{private T obj; //Affichage et taille import javafx.scene.control.PasswordField; peut faire : Class B extends A { Public void g( int) (…) ; } void affiche() { élément visité
public Boite(T obj){this.obj=obj;} S.O.P ("elements de numbersSet sont:"+ numbersSet); //ajouter les autres imports A a = new B(…) System.out.println(this); }} ArrayList<String> liste=new ArrayList<>(List.of("a","b"));
public void setObjet(T obj){this.obj=obj;} S.O.P ("taille de numbersSet est : " + numbersSet.size()); public class PasswordChanger extends Application { interface : *******annotationsss******* Iterator<String> it = liste.iterator();
public T getObjet(){return obj;} //Recherche et Suppression @Override public void start(Stage primaryStage) { *Une classe pourra implémenter plusieurs interfaces # Une annotation est une marque associée à un élément while (it.hasNext()) {S.O.P(it.next());}
public void afficherObj(){S.O.P("l'objet stocké : "+ obj);} S.O.P (numbersSet.contains(30)); VBox root = new VBox(10); une classe ne pouvait dériver que d’une seule classe (classe, méthode, champ…) pour fournir des =>ListIterator (bidirectionnel)
public Boolean Comparer(Boite<T> autreBoite){ numbersSet.remove(20); root.setPadding(new Insets(15)); abstraite ou non métadonnées exploitables par :le compilateur,Les outils Utilisé pour des collections comme LinkedList ou
return this.obj.equals(autreBoite.getObjet());}} S.O.P ("elements apres modification:" + numbersSet); Label title = new Label("FI 1 ‐"); *Dans la définition d’une interface, on ne peut trouver (ex. générateurs de code),L’exécution (via la réflexion) ArrayList :
public class TestBoit { ***TP Utilisation de TreeSet******* Label subtitle = new Label("Changer mot de passe"); que des en‐têtes de méthodes ou des constantes Annotations standards ‐‐next() / previous() : aller en avant ou en arrière
public static void main(String[] args) { TreeSet<String> animalName = new TreeSet<String>(); GridPane grid = new GridPane(); grid.setHgap(10); *Les méthodes d’une interface sont abstraites et @Deprecated *Marque un élément comme obsolète ‐‐add() / set():ajouter un elem / remplacer un élément
Boite<Integer> obj1=new Boite <Integer>(3); animalName.add("Cat");animalName.add("Tiger");anim grid.setVgap(10); publiques par defaut *Le compilateur génère un avertissement ListIterator<String> it = liste.listIterator(liste.size());
S.O.P("obj1 :");obj1.afficherObj(); alName.add("Dog");animalName.add("Lion"); grid.setPadding(new Insets(5, 0, 5, 0)); *Une même classe peut implémenter plusieurs interface *Signal : « N’utilisez plus cet élément, il existe une while (it.hasPrevious()) {S.O.P(it.previous());}
Boite<Integer> obj=new Boite <Integer>(3); animalName.add("Elephant"); Label nameLabel = new Label("Nom :"); Public interface I1{ void f() } meilleure alternative. » ***LinkedList***
obj.setObjet(5); //Affichage TextField nameValue = new TextField(); Public interface I2 void h() } @Override *Indique qu’une méthode redéfinit une ‐‐Liste doublement chaînée.‐‐Permet des parcours
S.O.P("obj : "); obj.afficherObj();S.O.P("comparaison de S.O.P ("Les animaux sont : " + animalName); nameValue.setText("Loto"); Class A implements I1,I2 { //definition les mehtod f et h } méthode d’une superclasse bidirectionnels avec ListIterator.
obj1 et obj :"+obj.Comparer(obj1)); //Operations avancees Label currentPasswordLabel = new Label("Mot de passe *classe dérivée peut implémenter une interface ou *Le compilateur :**Vérifie que la méthode existe bien ‐‐Méthodes : addFirst(elem), addLast(elem),
Boite<Double> obj2=new Boite <Double>(2.3); S.O.P ("Le premier animal est : " + animalName.first()); actuel :"); plusieur dans la superclasse **Génère une erreur si la signature removeFirst(), removeLast(), remove(elem)
S.O.P("double :"); obj2.afficherObj(); obj2.setObjet(5.5); S.O.P ("Le dernier animal est : " + animalName.last()); PasswordField currentPasswordField = new Public interface I { void f(int n) ; void(g) ; } ne correspond pas. Exemple : LinkedList<String> chaines = new LinkedList<>();
S.O.P("apres modification :"+obj2.getObjet()); Scanner sc = new Scanner(System.in); PasswordField(); Class A{…} class Creature {void fly() { }} chaines.addFirst("Fin");
Boite<String> obj3=new Boite <String>("oumeyma"); S.O.P ("Entrez un animal : "); String animal=sc.nextLine(); currentPasswordField.setPromptText("*****"); Class B extends A implements I { …} class Dragon extends Creature { @Override ***ArrayList***
S.O.P("String :");obj3.afficherObj(); S.O.P ("Les animaux inferieurs a " + animal + " sont : " + Label newPasswordLabel = new Label("Nouveau mot de Différences entre interface et classe abstr : void fly() { } // OK} ‐‐Tableau dynamique (accès rapide).‐‐Taille ajustable
obj3.setObjet("NOM"); animalName.headSet(animal)); }} passe :");PasswordField newPasswordField = new *class abst peut contenir une implémentation de Si la méth ne correspond pas, le compilateur le signale. dynamiquement.‐‐add(elem): ajoute en fin de liste‐‐
S.O.P("apres modification :"+obj3.getObjet());} }} *****TP calculator******** PasswordField(); méthodes, de champs, de constructeurs ## tandis **Annotations personnalisées : L’utilisateur peut définir add(index, elem): à une position donnée‐‐
********tp linkedlist avc prog generique ***** import javafx.application.*;javafx.stage.*;javafx.scene.*; newPasswordField.setPromptText("*****"); qu'une interface ne contient que des prototypes de ses propres annotations pour des traitements remove(index): supprime par rang‐‐ remove(elem):
class Personne implements Comparable<Personne> { javafx.scene.layout.*;javafx.scene.image.*;javafx.scene. Label confirmPasswordLabel = new Label("Retapez le méthodes et de propriétés spécifiques. supprime par valeur‐‐removeRange(start, end):
private String nom; private int age; control.*; mot de passe :"); *Une classe peut implémenter plusieurs interfaces, mais *****Programmation générique***** supprime plusieurs éléments consécutifs‐‐get(index),
public Personne(String nom, int age) {this.nom = nom; public class CalculatorApp extends Application { PasswordField confirmPasswordField = new elle ne peut hériter que d'une classe (abstraite ou autre) Permet d’écrire un code unique utilisable avec des set(index, elem): accès / modification directe
this.age = age;} Label label = new Label("0"); String currentInput = ""; PasswordField(); *Une interface définit un ensemble de méthodes objets de types différents, sans duplication. ArrayList<String> couleurs = new ArrayList<>();
public void afficher(){S.O.P(“Nom: "+ nom+ ", Âge: public static void main(String[] args) {launch(args);} confirmPasswordField.setPromptText("*****"); (signatures) sans implémentation. Et Les classes qui Exemple : manipuler des objets sans connaître leur couleurs.add("Vert"); couleurs.set(0, "Bleu");
"+age);} @Override public void start(Stage stage) throws grid.add(nameLabel, 0, 0); grid.add(nameValue, 1, 0); l'implémentent doivent fournir le code pour chaque ***HashSet et TreeSet***
type exact à l’avance.
public String getNom() {return nom;} Exception { String[] buttonLabel = { grid.add(currentPasswordLabel, 0, 1); méthode. Aucun doublon autorisé.*HashSet : non ordonné
*Classe générique
public int getAge() {return age;} "7", "4", "1", "C", grid.add(currentPasswordField, 1, 1); * Plusieurs classes peuvent implémenter différemment TreeSet : trié selon l’ordre naturel (Comparable) ou un
@Override public int compareTo(Personne autre) { "8", "5", "2", "0", grid.add(newPasswordLabel, 0, 2); **Définie avec un paramètre de type (ex. T) :
une même interface Comparator *add(elem) : ajoute si l’élément n’est pas
return Integer.compare(this.age, autre.age); }} "9", "6", "3", "=", grid.add(newPasswordField, 1, 2); class Couple<T> { private T x, y;
**Classes enveloppes : Permet de manipuler les types déjà présent *remove(elem) : supprime un élément
public class Main {public static void main(String[] args) { "+", "‐", "*", "/" }; grid.add(confirmPasswordLabel, 0, 3); public Couple(T x, T y) { this.x = x; this.y = y;}
primitifs comme des objets Boolean, Character, Byte, donné
LinkedList<Personne> personnes = new LinkedList<>(); var root = new VBox(); GridPane buttons = new grid.add(confirmPasswordField, 1, 3); public void affiche() { System.out.println(x + ", " + y);}
Short, Integer, Long, Float < = > boolean, char, byte, *iterator():pour parcourir les éléments
personnes.add(new Personne("Fatima", 24)); GridPane(); Image icon = new Image("icon.png"); Button submitButton = new Button("Modifier"); public T getPremier() {return x;}}
short, int, long, float (monodirectionnel uniquement)
personnes.add(new Personne("ELHABIB", 30)); buttons.setHgap(10); buttons.setVgap(10); root.getChildren().addAll(title, subtitle, grid, T : représente un type quelconque (classe). HashSet<String> set = new HashSet<>(); set.add("a");
* toutes les classes enveloppes disposent d’un *Utilisation
personnes.add(new Personne("OUMEYMA", 20)); label.setStyle("‐fx‐font‐size: 30; ‐fx‐padding: 20;"); submitButton); constructeur recevant un argument d’un type primitif: Méthodes pour les Set :
personnes.add(new Personne("AMINE", 16)); int row = 0, col = 0; for (String text : buttonLabel) { Scene scene = new Scene(root, 350, 300); À l’instanciation, on précise le type effectif : isEmpty():retourne true si le set est vide
Integer mObj = new Integer(12); // mObj contient une Couple<Integer> c = new Couple<>(1, 2); c.affiche();
S.O.P("Liste avant tri:"); afficherListe(personnes); Button button = new Button(text); primaryStage.setTitle("Changer mot de passe"); référence à un objet de t ype Integer encapsulant la *containsAll(bib2):vérifier si le set contient tous les
trierParAge(personnes); button.setPrefSize(50, 50); primaryStage.setScene(scene); Integer premier = c.getPremier(); éléments d’un autre set *retainAll(bib2):intersection
valeur 12
S.O.P("\nListe après tri par âge:"); button.setOnAction(e ‐> handleButtonClick(text)); primaryStage.show();} ** Les types primitifs (ex. int) doivent être remplacés entre les deux sets (garde les communs)*
*Elles disposent toutes d’une méthode de la forme
afficherListe(personnes); buttons.add(button, row, col); public static void main(String[] args) {launch(args);}} par leur wrapper (ex. Integer). removeAll(bib2):différence (supprime les éléments
xxxValue (xxx représentant le nom du type promitif) qui
String nomRecherche = "Bob"; col++; if (col == 4) {col = 0; row++;} ********cours de la 1ere partie java********** *********Collections************ communs avec bib2)
permet de retrouver la valeur dans le type primitif
Personne p = switch (button.getText()) { Object : Class dérive implicitement tout classe => classs correspondant Elles font partie du package java.util et permettent ***Méthodes valables pour toutes les collections :
rechercherParNom(personnes,nomRecherche); case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ‐> { point extends Object{….} Une variable de type Object d'utiliser différentes structures de données, comme : addAll(c): union retainAll(c): intersection
Int n = nObj.intValue();//n contient 12
if (p != null) { button.setStyle("‐fx‐background‐color: #E3A5C7"); peut être utilisée pour référencer un objet de type *Listes (ex. : suite ordonnée d’éléments)*Vecteurs removeAll(c): différence
Emballage (autoboxing) :Conversion d’un type
S.O.P("\nPersonne trouvée :");p.afficher();} button.setOnMouseEntered(e ‐> button.setStyle("‐fx‐ Methode toStirng : par defaut : il renvoit : le nom de dynamiques (tableaux ajustables)*Ensembles (pas de
primitif→ objet wrapper.
else{S.O.P("\n" + nomRecherche + " pas trouvé ");}} background‐color:#B692C2;")); class cocernée + @d’object en hexa (Point@1234F..) doublons)*Queues (files d’attente)*Tables associatives
Integer nObj = 12; // équivalent à Integer.valueOf(12)
(paires clé/valeur → comme un dic onnaire)