1.3.2 – Cycle de vie et affichage d'un Stage

Comprendre le cycle de vie d'une application JavaFX et savoir afficher un Stage est essentiel. Cette section vous explique comment JavaFX démarre votre application et comment configurer la fenêtre principale.

🔄 Cycle de vie d'une application JavaFX

Une application JavaFX suit un cycle de vie bien défini avec trois méthodes principales :

1. init() : Appelée avant start(), pour l'initialisation (optionnelle)
2. start() : Appelée pour démarrer l'application (obligatoire)
3. stop() : Appelée quand l'application se ferme (optionnelle)

Méthode init()

La méthode init() est appelée avant start(). Elle est optionnelle et sert à initialiser des ressources :

@Override
public void init() {
    // Initialisation avant le démarrage
    // Par exemple : charger des données, initialiser des variables
    System.out.println("Initialisation de l'application...");
}

Méthode start()

La méthode start() est obligatoire et est appelée après init(). C'est ici que vous créez et affichez votre interface :

@Override
public void start(Stage primaryStage) {
    // Créer et configurer l'interface
    // Afficher la fenêtre
}

Méthode stop()

La méthode stop() est appelée quand l'application se ferme. Elle est optionnelle et sert à nettoyer les ressources :

@Override
public void stop() {
    // Nettoyage avant la fermeture
    // Par exemple : sauvegarder des données, fermer des connexions
    System.out.println("Fermeture de l'application...");
}

🪟 Créer et afficher un Stage

Le Stage représente la fenêtre de votre application. JavaFX vous fournit automatiquement un primaryStage dans la méthode start().

Exemple minimal : Afficher une fenêtre vide

package application;

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

public class Main extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // Configurer le titre de la fenêtre
        primaryStage.setTitle("Ma Première Application");
        
        // Définir la taille de la fenêtre
        primaryStage.setWidth(800);
        primaryStage.setHeight(600);
        
        // Afficher la fenêtre
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

⚙️ Méthodes principales du Stage

Voici les méthodes les plus utilisées pour configurer un Stage :

Configuration de base

// Titre de la fenêtre
primaryStage.setTitle("Mon Application");

// Taille de la fenêtre
primaryStage.setWidth(800);      // Largeur en pixels
primaryStage.setHeight(600);     // Hauteur en pixels

// Position de la fenêtre (optionnel)
primaryStage.setX(100);          // Position X (distance depuis la gauche)
primaryStage.setY(100);          // Position Y (distance depuis le haut)

// Redimensionnement
primaryStage.setResizable(true); // Permet ou non le redimensionnement

// Toujours au premier plan
primaryStage.setAlwaysOnTop(false); // Fenêtre toujours visible par-dessus les autres

// Mode plein écran
primaryStage.setFullScreen(false);  // Mode plein écran (ou non)

Méthodes utilitaires

// Afficher la fenêtre
primaryStage.show();

// Cacher la fenêtre
primaryStage.hide();

// Fermer la fenêtre
primaryStage.close();

// Vérifier si la fenêtre est affichée
boolean visible = primaryStage.isShowing();

// Centrer la fenêtre sur l'écran
primaryStage.centerOnScreen();

📝 Exemple complet : Application avec Stage configuré

package application;

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

public class Main extends Application {
    
    @Override
    public void init() {
        System.out.println("Initialisation...");
    }
    
    @Override
    public void start(Stage primaryStage) {
        // Configuration du Stage
        primaryStage.setTitle("Ma Première Application JavaFX");
        primaryStage.setWidth(800);
        primaryStage.setHeight(600);
        primaryStage.setResizable(true);
        
        // Centrer la fenêtre sur l'écran
        primaryStage.centerOnScreen();
        
        // Afficher la fenêtre
        primaryStage.show();
        
        System.out.println("Application démarrée !");
    }
    
    @Override
    public void stop() {
        System.out.println("Application fermée.");
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

⚠️ Erreurs courantes

Voici les erreurs les plus fréquentes lors de la création d'un Stage :

• Oublier show() : La fenêtre ne s'affichera pas si vous oubliez d'appeler primaryStage.show()
• Appeler show() avant de configurer : Configurez d'abord le Stage, puis affichez-le
• Ne pas définir de taille : Si vous ne définissez pas de taille, la fenêtre sera très petite ou invisible

💡 Points clés à retenir

• Cycle de vie : init() → start() → stop()
• start() : Méthode obligatoire, appelée automatiquement
• primaryStage : Fenêtre principale fournie par JavaFX
• setTitle() : Définit le titre de la fenêtre
• setWidth() / setHeight() : Définit la taille de la fenêtre
• show() : Affiche la fenêtre (obligatoire !)
• centerOnScreen() : Centre la fenêtre sur l'écran

1.3.3 – Ajouter un Label dans un layout simple

Maintenant que vous savez créer et afficher un Stage, vous allez apprendre à ajouter du contenu. Dans cette section, vous découvrirez les layouts (conteneurs) et comment ajouter votre premier composant : un Label.

📦 Les Layouts (conteneurs)

Un layout (ou conteneur) est un composant qui organise d'autres composants. Pour afficher du contenu dans une Scene, vous devez d'abord créer un layout qui servira de Node racine.

Layouts simples pour débuter

• VBox : Organise les composants verticalement (un en dessous de l'autre)
• HBox : Organise les composants horizontalement (un à côté de l'autre)
• StackPane : Superpose les composants (un par-dessus l'autre)

🏷️ Le composant Label

Un Label est un composant qui affiche du texte. C'est l'un des composants les plus simples de JavaFX.

Créer un Label

// Label avec texte
Label label = new Label("Bonjour JavaFX !");

// Label vide (texte défini plus tard)
Label labelVide = new Label();
labelVide.setText("Texte défini après création");

📝 Exemple complet : Application avec Label

Voici un exemple complet qui combine tout ce que vous avez appris :

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 Main extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // ============================================
        // ÉTAPE 1 : Créer un layout (conteneur)
        // ============================================
        VBox root = new VBox();
        
        // ============================================
        // ÉTAPE 2 : Créer un Label
        // ============================================
        Label label = new Label("Bonjour JavaFX !");
        
        // ============================================
        // ÉTAPE 3 : Ajouter le Label au layout
        // ============================================
        root.getChildren().add(label);
        
        // ============================================
        // ÉTAPE 4 : Créer une Scene avec le layout
        // ============================================
        Scene scene = new Scene(root, 400, 300);
        
        // ============================================
        // ÉTAPE 5 : Configurer et afficher le Stage
        // ============================================
        primaryStage.setTitle("Ma Première Application");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

🎨 Personnaliser le Label

Vous pouvez personnaliser l'apparence d'un Label de plusieurs façons :

Exemple : Label personnalisé

Label label = new Label("Mon Label Personnalisé");

// Changer le texte
label.setText("Nouveau texte");

// Style inline (CSS)
label.setStyle("-fx-font-size: 18px; -fx-font-weight: bold; -fx-text-fill: blue;");

// Ou utiliser des méthodes JavaFX
label.setStyle("-fx-font-size: 20px;");
label.setStyle("-fx-text-fill: red;");

📦 Personnaliser le VBox

Vous pouvez aussi personnaliser le VBox pour améliorer l'apparence :

VBox root = new VBox();

// Espacement entre les éléments
root.setSpacing(10);

// Padding (marge intérieure)
root.setStyle("-fx-padding: 20px;");

// Alignement
root.setStyle("-fx-alignment: center;");

// Ou combiner plusieurs styles
root.setStyle("-fx-padding: 20px; -fx-alignment: center; -fx-background-color: #f0f0f0;");

📝 Exemple amélioré : Application avec Label stylisé

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 Main extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // Créer le layout avec espacement
        VBox root = new VBox(20); // 20 pixels d'espacement
        root.setStyle("-fx-padding: 30px; -fx-alignment: center;");
        
        // Créer un Label stylisé
        Label label = new Label("Bienvenue dans JavaFX !");
        label.setStyle("-fx-font-size: 24px; -fx-font-weight: bold; -fx-text-fill: #2c3e50;");
        
        // Ajouter le Label au layout
        root.getChildren().add(label);
        
        // Créer la Scene
        Scene scene = new Scene(root, 500, 400);
        
        // Configurer et afficher
        primaryStage.setTitle("Ma Première Application JavaFX");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

🔄 Ordre des opérations (important !)

L'ordre dans lequel vous créez et assemblez les composants est important :

1. Créer le layout (VBox, HBox, etc.)
2. Créer les composants (Label, Button, etc.)
3. Ajouter les composants au layout (getChildren().add())
4. Créer la Scene avec le layout comme Node racine
5. Attacher la Scene au Stage (setScene())
6. Afficher le Stage (show())

💡 Points clés à retenir

• Layout : Conteneur qui organise les composants (VBox, HBox, etc.)
• Label : Composant pour afficher du texte
• VBox : Layout simple qui organise verticalement
• getChildren().add() : Méthode pour ajouter un composant à un layout
• Scene : Doit avoir un Node racine (le layout)
• Ordre : Layout → Composants → Ajouter → Scene → Stage → show()
• Style : Utilisez setStyle() avec du CSS pour personnaliser

✅ Checklist de votre première application

Vérifiez que votre application contient bien :

• ✅ Une classe qui étend Application
• ✅ La méthode main() avec launch(args)
• ✅ La méthode start(Stage primaryStage)
• ✅ Un layout créé (VBox, HBox, etc.)
• ✅ Au moins un composant (Label) créé
• ✅ Le composant ajouté au layout
• ✅ Une Scene créée avec le layout
• ✅ La Scene attachée au Stage
• ✅ Le Stage configuré (titre, taille)
• ✅ primaryStage.show() appelé