1.1.2 – JavaFX vs Swing (niveau débutant)

Si vous avez déjà entendu parler de Swing, vous vous demandez peut-être quelle est la différence avec JavaFX. Cette section compare les deux technologies de manière simple et accessible pour les débutants.

🔄 Vue d'ensemble : Swing vs JavaFX

Swing et JavaFX sont deux bibliothèques Java pour créer des interfaces graphiques, mais JavaFX est plus récent et moderne. Voici les principales différences :

Tableau comparatif simplifié

🎨 Différences visuelles

La différence la plus visible entre Swing et JavaFX est l'apparence des interfaces :

• Swing : Utilise le "Look and Feel" du système d'exploitation, ce qui donne un aspect parfois daté et peu personnalisable
• JavaFX : Permet une personnalisation complète avec CSS, créant des interfaces modernes et attrayantes

⚡ Performance et rendu

JavaFX utilise le GPU (carte graphique) pour le rendu, ce qui offre de meilleures performances :

• Swing : Rendu par le CPU, peut être lent pour les animations et les interfaces complexes
• JavaFX : Rendu par le GPU, animations fluides même avec beaucoup d'éléments

🛠️ Outils de développement

JavaFX offre des outils plus modernes pour créer des interfaces :

• Swing : Tout doit être créé en code Java, ce qui peut être long et fastidieux
• JavaFX : Scene Builder permet de créer des interfaces visuellement en glissant-déposant, puis génère le FXML automatiquement

🎯 Quand utiliser Swing ?

Swing reste utile dans certains cas :

• Applications existantes : Si vous maintenez une application Swing existante, il peut être plus simple de continuer avec Swing
• Compatibilité : Swing est inclus dans tous les JDK, JavaFX nécessite une dépendance supplémentaire (depuis Java 11)
• Simplicité : Pour des interfaces très simples, Swing peut suffire

🎯 Quand utiliser JavaFX ?

JavaFX est recommandé pour :

• Tous les nouveaux projets : C'est la technologie moderne recommandée par Oracle
• Interfaces modernes : Si vous voulez une apparence moderne et personnalisable
• Animations et effets : Pour des interfaces avec animations, transitions et effets visuels
• Productivité : Scene Builder accélère considérablement le développement
• Performance : Pour des applications nécessitant de bonnes performances graphiques

📚 Migration de Swing vers JavaFX

Si vous connaissez déjà Swing, la bonne nouvelle est que :

• Concepts similaires : Les concepts de base (fenêtres, composants, événements) sont similaires
• Java toujours : Vous continuez à utiliser Java, la syntaxe est la même
• Nouveaux outils : FXML et Scene Builder sont des ajouts qui facilitent le développement
• Courbe d'apprentissage : Si vous connaissez Swing, vous apprendrez JavaFX rapidement

💡 Points clés à retenir

• JavaFX est plus récent : Créé pour remplacer Swing avec des technologies modernes
• Meilleure performance : Utilise le GPU pour un rendu plus rapide
• Outils visuels : Scene Builder permet de créer des interfaces visuellement
• Stylisation CSS : Personnalisation complète avec des feuilles de style
• Recommandé par Oracle : Technologie recommandée pour tous les nouveaux projets
• Swing en maintenance : Toujours supporté mais plus de nouvelles fonctionnalités
• Concepts similaires : Si vous connaissez Swing, JavaFX sera facile à apprendre

1.1.3 – Architecture de base : Stage, Scene, Node

JavaFX utilise une architecture hiérarchique basée sur trois concepts fondamentaux : Stage, Scene et Node. Comprendre ces trois concepts est essentiel pour maîtriser JavaFX.

🏗️ Vue d'ensemble de l'architecture

L'architecture JavaFX suit une hiérarchie simple :

🎭 Stage : La fenêtre

Le Stage représente la fenêtre principale de votre application. C'est le conteneur de plus haut niveau.

Caractéristiques du Stage

• Fenêtre native : Correspond à une fenêtre du système d'exploitation
• Un Stage = Une fenêtre : Chaque Stage est une fenêtre indépendante
• Propriétés : Titre, taille, position, visibilité, mode plein écran
• Point d'entrée : C'est par le Stage que vous commencez votre application JavaFX

Exemple : Créer un Stage

package application;

import javafx.application.Application;
import javafx.stage.Stage;

public class MonApplication extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // primaryStage est le Stage principal fourni par JavaFX
        
        // Configurer le Stage
        primaryStage.setTitle("Ma Première Application JavaFX");
        primaryStage.setWidth(800);
        primaryStage.setHeight(600);
        primaryStage.setResizable(true);
        
        // Afficher le Stage
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

🎬 Scene : Le contenu de la fenêtre

La Scene représente le contenu affiché dans le Stage. Une Scene contient tous les éléments visuels de votre interface.

Caractéristiques de la Scene

• Conteneur de Nodes : La Scene contient un Node racine (root) qui peut contenir d'autres Nodes
• Une Scene = Un écran : Vous pouvez changer de Scene pour changer complètement l'interface affichée
• Propriétés : Taille, couleur de fond, styles CSS
• Liaison Stage-Scene : Un Stage affiche une Scene à la fois

Exemple : Créer une Scene

package application;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class MonApplication extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // Créer un Node racine (VBox est un conteneur vertical)
        VBox root = new VBox();
        
        // Ajouter des éléments à la Scene
        Label label = new Label("Bonjour JavaFX !");
        root.getChildren().add(label);
        
        // Créer la Scene avec le Node racine
        Scene scene = new Scene(root, 800, 600);
        
        // Attacher la Scene au Stage
        primaryStage.setScene(scene);
        
        // Configurer et afficher
        primaryStage.setTitle("Ma Première Application");
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

🎨 Node : Les éléments de l'interface

Un Node est un élément visuel de l'interface. Tous les composants JavaFX (boutons, labels, champs de texte, etc.) sont des Nodes.

Types de Nodes

• Nodes de contrôle : Boutons, Labels, TextField, ListView, etc. (éléments interactifs)
• Nodes de conteneur (Layouts) : VBox, HBox, BorderPane, etc. (organisent d'autres Nodes)
• Nodes de forme : Rectangle, Circle, Line, etc. (formes géométriques)
• Nodes multimédias : ImageView, MediaView, etc. (images, vidéos)

Exemple : Créer et utiliser des Nodes

package application;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class MonApplication extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // Créer le Node racine (conteneur)
        VBox root = new VBox();
        root.setSpacing(10); // Espacement entre les éléments
        
        // Créer des Nodes (éléments de l'interface)
        Label labelTitre = new Label("Bienvenue !");
        TextField champTexte = new TextField();
        champTexte.setPromptText("Entrez votre nom");
        Button bouton = new Button("Cliquez-moi");
        
        // Ajouter les Nodes au conteneur racine
        root.getChildren().addAll(labelTitre, champTexte, bouton);
        
        // Créer la Scene avec le Node racine
        Scene scene = new Scene(root, 400, 300);
        
        // Attacher au Stage
        primaryStage.setScene(scene);
        primaryStage.setTitle("Exemple Nodes");
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

🔗 Relations entre Stage, Scene et Node

Voici comment ces trois concepts s'articulent :

📝 Exemple complet : Application simple

Voici un exemple complet illustrant Stage, Scene et Node :

package application;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class ApplicationComplete extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // ============================================
        // ÉTAPE 1 : Créer le Node racine (conteneur)
        // ============================================
        VBox root = new VBox(20); // 20 = espacement entre éléments
        root.setStyle("-fx-padding: 20; -fx-alignment: center;");
        
        // ============================================
        // ÉTAPE 2 : Créer des Nodes (éléments)
        // ============================================
        Label label = new Label("Ma Première Application JavaFX");
        label.setStyle("-fx-font-size: 18px; -fx-font-weight: bold;");
        
        Button bouton = new Button("Cliquez ici");
        bouton.setOnAction(e -> {
            label.setText("Vous avez cliqué !");
        });
        
        // ============================================
        // ÉTAPE 3 : Ajouter les Nodes au conteneur
        // ============================================
        root.getChildren().addAll(label, bouton);
        
        // ============================================
        // ÉTAPE 4 : Créer la Scene avec le Node racine
        // ============================================
        Scene scene = new Scene(root, 600, 400);
        
        // ============================================
        // ÉTAPE 5 : Attacher la Scene au Stage
        // ============================================
        primaryStage.setScene(scene);
        primaryStage.setTitle("Architecture JavaFX");
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

🎯 Points importants à retenir

• Stage : La fenêtre de l'application (une fenêtre = un Stage)
• Scene : Le contenu affiché dans le Stage (un écran = une Scene)
• Node : Tous les éléments visuels (boutons, labels, conteneurs, etc.)
• Hiérarchie : Stage → Scene → Node racine → autres Nodes
• Node racine obligatoire : Une Scene doit toujours avoir un Node racine
• Un Stage, une Scene : Un Stage affiche une Scene à la fois (mais vous pouvez changer de Scene)
• Nodes imbriqués : Les Nodes peuvent contenir d'autres Nodes (conteneurs)

💡 Analogie simple

💡 Points clés à retenir

• Stage : Fenêtre de l'application, contient une Scene
• Scene : Contenu de la fenêtre, contient un Node racine
• Node : Élément visuel (bouton, label, conteneur, etc.)
• Hiérarchie : Stage → Scene → Node racine → Nodes enfants
• Node racine obligatoire : Toute Scene doit avoir un Node racine
• Structure simple : Cette architecture est la base de toutes les applications JavaFX