JavaFX - Applicazione
In questo capitolo, discuteremo in dettaglio la struttura di un'applicazione JavaFX e impareremo anche a creare un'applicazione JavaFX con un esempio.
Struttura dell'applicazione JavaFX
In generale, un'applicazione JavaFX avrà tre componenti principali, vale a dire Stage, Scene e Nodes come mostrato nel diagramma seguente.
Palcoscenico
Uno stage (una finestra) contiene tutti gli oggetti di un'applicazione JavaFX. È rappresentato daStage classe del pacchetto javafx.stage. La fase principale è creata dalla piattaforma stessa. L'oggetto stage creato viene passato come argomento al filestart() metodo del Application classe (spiegato nella sezione successiva).
Uno stadio ha due parametri che determinano la sua posizione e cioè Width e Height. È suddiviso in Area contenuto e Decorazioni (barra del titolo e bordi).
Sono disponibili cinque tipi di fasi:
- Decorated
- Undecorated
- Transparent
- Unified
- Utility
Devi chiamare il show() metodo per visualizzare il contenuto di una fase.
Scena
Una scena rappresenta il contenuto fisico di un'applicazione JavaFX. Contiene tutti i contenuti di un grafico di scena. La classeScene del pacchetto javafx.scenerappresenta l'oggetto scena. In un'istanza, l'oggetto scena viene aggiunto a una sola fase.
Puoi creare una scena istanziando la Scene Class. Puoi optare per la dimensione della scena passando le sue dimensioni (altezza e larghezza) insieme alroot node al suo costruttore.
Grafico e nodi della scena
UN scene graphè una struttura di dati ad albero (gerarchica) che rappresenta il contenuto di una scena. Al contrario, anode è un oggetto visivo / grafico di un grafico di scena.
Un nodo può includere:
Oggetti geometrici (grafici) (2D e 3D) come: cerchio, rettangolo, poligono, ecc.
Controlli dell'interfaccia utente come: pulsante, casella di controllo, casella di scelta, area di testo, ecc.
Contenitori (riquadri layout) come riquadro bordo, riquadro griglia, riquadro flusso, ecc.
Elementi multimediali come oggetti audio, video e immagine.
Il Node Classe del pacchetto javafx.scene rappresenta un nodo in JavaFX, questa classe è la super classe di tutti i nodi.
Come discusso in precedenza, un nodo è di tre tipi:
Root Node - Il primo grafico scena è noto come nodo radice.
Branch Node/Parent Node- I nodi con nodi figlio sono noti come nodi ramo / padre. La classe astratta denominataParent del pacchetto javafx.scene è la classe base di tutti i nodi padre e quei nodi padre saranno dei seguenti tipi:
Group- Un nodo di gruppo è un nodo collettivo che contiene un elenco di nodi figli. Ogni volta che viene eseguito il rendering del nodo del gruppo, tutti i suoi nodi figlio vengono visualizzati in ordine. Qualsiasi trasformazione, stato dell'effetto applicato al gruppo verrà applicato a tutti i nodi figlio.
Region - È la classe base di tutti i controlli dell'interfaccia utente basati sul nodo JavaFX, come Grafico, Riquadro e Controllo.
WebView - Questo nodo gestisce il motore web e ne visualizza i contenuti.
Leaf Node- Il nodo senza nodi figlio è noto come nodo foglia. Ad esempio, Rectangle, Ellipse, Box, ImageView, MediaView sono esempi di nodi foglia.
È obbligatorio passare il nodo radice al grafico della scena. Se il gruppo viene passato come root, tutti i nodi verranno ritagliati sulla scena e qualsiasi alterazione delle dimensioni della scena non influenzerà il layout della scena.
Creazione di un'applicazione JavaFX
Per creare un'applicazione JavaFX, è necessario creare un'istanza della classe Application e implementare il suo metodo astratto start(). In questo metodo, scriveremo il codice per l'applicazione JavaFX.
Classe di applicazione
Il Application classe del pacchetto javafx.applicationè il punto di ingresso dell'applicazione in JavaFX. Per creare un'applicazione JavaFX, è necessario ereditare questa classe e implementare il suo metodo astrattostart(). In questo metodo, è necessario scrivere l'intero codice per la grafica JavaFX
Nel main metodo, devi avviare l'applicazione utilizzando il launch()metodo. Questo metodo chiama internamente il filestart() metodo della classe Application come mostrato nel seguente programma.
public class JavafxSample extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
/*
Code for JavaFX application.
(Stage, scene, scene graph)
*/
}
public static void main(String args[]){
launch(args);
}
}
All'interno del start() metodo, per creare una tipica applicazione JavaFX, è necessario seguire i passaggi indicati di seguito:
Prepara un grafico di scena con i nodi richiesti.
Preparare una scena con le dimensioni richieste e aggiungervi il grafico della scena (nodo radice del grafico della scena).
Prepara uno stage e aggiungi la scena allo stage e mostra i contenuti dello stage.
Preparazione del grafico della scena
Secondo la tua applicazione, devi preparare un grafico di scena con i nodi richiesti. Poiché il nodo radice è il primo nodo, è necessario creare un nodo radice. Come nodo radice, puoi scegliere dal fileGroup, Region or WebView.
Group - Un nodo Gruppo è rappresentato dalla classe denominata Group che appartiene al pacchetto javafx.scene, puoi creare un nodo Gruppo istanziando questa classe come mostrato di seguito.
Group root = new Group();
Il getChildren() metodo del Group class ti dà un oggetto del ObservableListclasse che contiene i nodi. Possiamo recuperare questo oggetto e aggiungervi nodi come mostrato di seguito.
//Retrieving the observable list object
ObservableList list = root.getChildren();
//Setting the text object as a node
list.add(NodeObject);
Possiamo anche aggiungere oggetti Node al gruppo, semplicemente passandoli al file Group class e al suo costruttore al momento dell'istanziazione, come mostrato di seguito.
Group root = new Group(NodeObject);
Region - È la classe Base di tutti i controlli dell'interfaccia utente basati su nodi JavaFX, come -
Chart - Questa classe è la classe base di tutti i grafici e appartiene al pacchetto javafx.scene.chart.
Questa classe ha due sottoclassi, che sono: PieChart e XYChart. Questi due a loro volta hanno sottoclassi comeAreaChart, BarChart, BubbleChart, ecc. utilizzati per disegnare diversi tipi di grafici piano XY in JavaFX.
Puoi utilizzare queste classi per incorporare grafici nella tua applicazione.
Pane - Un riquadro è la classe base di tutti i riquadri di layout come AnchorPane, BorderPane, DialogPane, ecc. Questa classe appartiene a un pacchetto chiamato come - javafx.scene.layout.
È possibile utilizzare queste classi per inserire layout predefiniti nella propria applicazione.
Control - È la classe base dei controlli dell'interfaccia utente come Accordion, ButtonBar, ChoiceBox, ComboBoxBase, HTMLEditor, etc. This class belongs to the package javafx.scene.control.
È possibile utilizzare queste classi per inserire vari elementi dell'interfaccia utente nell'applicazione.
In un gruppo, puoi istanziare una qualsiasi delle classi sopra menzionate e usarle come nodi root, come mostrato nel programma seguente.
//Creating a Stack Pane
StackPane pane = new StackPane();
//Adding text area to the pane
ObservableList list = pane.getChildren();
list.add(NodeObject);
WebView - Questo nodo gestisce il motore web e ne visualizza i contenuti.
Di seguito è riportato un diagramma che rappresenta la gerarchia delle classi dei nodi di JavaFX.
Preparare la scena
Una scena JavaFX è rappresentata dal file Scene classe del pacchetto javafx.scene. Puoi creare una scena istanziando questa classe come mostrato nel seguente blocco di merluzzo.
Durante la creazione dell'istanza, è obbligatorio passare l'oggetto radice al costruttore della classe scene.
Scene scene = new Scene(root);
Puoi anche passare due parametri di tipo double che rappresentano l'altezza e la larghezza della scena come mostrato di seguito.
Scene scene = new Scene(root, 600, 300);
Preparare il palco
Questo è il contenitore di qualsiasi applicazione JavaFX e fornisce una finestra per l'applicazione. È rappresentato dalStage classe del pacchetto javafx.stage. Un oggetto di questa classe viene passato come parametro distart() metodo del Application classe.
Usando questo oggetto, puoi eseguire varie operazioni sullo stage. Principalmente puoi eseguire le seguenti operazioni:
Imposta il titolo per lo stage utilizzando il metodo setTitle().
Attacca l'oggetto scena allo stage usando il setScene() metodo.
Visualizza il contenuto della scena usando il show() metodo come mostrato di seguito.
//Setting the title to Stage.
primaryStage.setTitle("Sample application");
//Setting the scene to Stage
primaryStage.setScene(scene);
//Displaying the stage
primaryStage.show();
Ciclo di vita dell'applicazione JavaFX
La classe dell'applicazione JavaFX ha tre metodi del ciclo di vita, che sono:
start() - Il metodo del punto di ingresso in cui deve essere scritto il codice grafico JavaFX.
stop() - Un metodo vuoto che può essere sovrascritto, qui puoi scrivere la logica per fermare l'applicazione.
init() - Un metodo vuoto che può essere sovrascritto, ma non è possibile creare stage o scene in questo metodo.
Oltre a questi, fornisce un metodo statico denominato launch() per avviare l'applicazione JavaFX.
Dal momento che il launch()è statico, è necessario chiamarlo da un contesto statico (principale in genere). Ogni volta che viene avviata un'applicazione JavaFX, verranno eseguite le seguenti azioni (nello stesso ordine).
Viene creata un'istanza della classe dell'applicazione.
Init() viene chiamato il metodo.
Il start() viene chiamato il metodo.
Il programma di avvio attende che l'applicazione termini e chiama il file stop() metodo.
Chiusura dell'applicazione JavaFX
Quando l'ultima finestra dell'applicazione viene chiusa, l'applicazione JavaFX viene terminata implicitamente. È possibile disattivare questo comportamento passando il valore booleano "False" al metodo statico setImplicitExit() (dovrebbe essere chiamato da un contesto statico).
È possibile terminare un'applicazione JavaFX in modo esplicito utilizzando i metodi Platform.exit() o System.exit(int).
Esempio 1: creazione di una finestra vuota
Questa sezione insegna come creare un'applicazione di esempio JavaFX che visualizza una finestra vuota. Di seguito sono riportati i passaggi:
Passaggio 1: creazione di una classe
Crea una classe Java ed eredita il file Application classe del pacchetto javafx.application e implementare il metodo start () di questa classe come segue.
public class JavafxSample extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
}
}
Passaggio 2: creazione di un oggetto gruppo
Nel start() metodo crea un oggetto gruppo istanziando la classe denominata Group, che appartiene al pacchetto javafx.scene, come segue.
Group root = new Group();
Passaggio 3: creazione di un oggetto scena
Crea una scena istanziando la classe denominata Scene che appartiene al pacchetto javafx.scene. A questa classe, passa l'oggetto Group(root), creato nel passaggio precedente.
Oltre all'oggetto radice, puoi anche passare due parametri doppi che rappresentano l'altezza e la larghezza dello schermo insieme all'oggetto della classe Group come segue.
Scene scene = new Scene(root,600, 300);
Passaggio 4: impostazione del titolo dello stage
Puoi impostare il titolo dello stage utilizzando il file setTitle() metodo del Stageclasse. IlprimaryStage è un oggetto Stage che viene passato al metodo di avvio della classe scene, come parametro.
Usando il primaryStage oggetto, imposta il titolo della scena come Sample Application come mostrato di seguito.
primaryStage.setTitle("Sample Application");
Passaggio 5: aggiunta di scene allo stage
Puoi aggiungere un oggetto Scene allo stage utilizzando il metodo setScene() della classe denominata Stage. Aggiungi l'oggetto Scene preparato nei passaggi precedenti utilizzando questo metodo come mostrato di seguito.
primaryStage.setScene(scene);
Passaggio 6: visualizzazione dei contenuti dello stage
Visualizza il contenuto della scena utilizzando il metodo denominato show() del Stage classe come segue.
primaryStage.show();
Passaggio 7: avvio dell'applicazione
Avvia l'applicazione JavaFX chiamando il metodo statico launch() del Application class dal metodo principale come segue.
public static void main(String args[]){
launch(args);
}
Esempio
Il seguente programma genera una finestra JavaFX vuota. Salva questo codice in un file con il nomeJavafxSample.java
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
public class JavafxSample extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
//creating a Group object
Group group = new Group();
//Creating a Scene by passing the group object, height and width
Scene scene = new Scene(group ,600, 300);
//setting color to the scene
scene.setFill(Color.BROWN);
//Setting the title to Stage.
primaryStage.setTitle("Sample Application");
//Adding the scene to Stage
primaryStage.setScene(scene);
//Displaying the contents of the stage
primaryStage.show();
}
public static void main(String args[]){
launch(args);
}
}
Compilare ed eseguire il file java salvato dal prompt dei comandi utilizzando i seguenti comandi.
javac JavafxSample.java
java JavafxSample
All'esecuzione, il programma di cui sopra genera una finestra JavaFX come mostrato di seguito.
Esempio 2: disegno di una linea retta
Nell'esempio precedente, abbiamo visto come creare uno stage vuoto, ora in questo esempio proviamo a disegnare una linea retta utilizzando la libreria JavaFX.
Di seguito sono riportati i passaggi:
Passaggio 1: creazione di una classe
Crea una classe Java ed eredita il file Application classe del pacchetto javafx.application e implementare il start() metodo di questa classe come segue.
public class DrawingLine extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
}
}
Passaggio 2: creazione di una linea
È possibile creare una riga in JavaFX istanziando la classe denominata Line che appartiene a un pacchetto javafx.scene.shape, creare un'istanza di questa classe come segue.
//Creating a line object
Line line = new Line();
Passaggio 3: impostazione delle proprietà sulla linea
Specificare le coordinate per disegnare la linea su un piano XY impostando le proprietà startX, startY, endX e endY, utilizzando i rispettivi metodi setter come mostrato nel seguente blocco di codice.
line.setStartX(100.0);
line.setStartY(150.0);
line.setEndX(500.0);
line.setEndY(150.0);
Passaggio 4: creazione di un oggetto gruppo
Nel metodo start () creare un oggetto gruppo istanziando la classe denominata Group, che appartiene al pacchetto javafx.scene.
Passa l'oggetto Line (nodo), creato nel passaggio precedente, come parametro al costruttore della classe Group, per aggiungerlo al gruppo come segue:
Group root = new Group(line);
Passaggio 5: creazione di un oggetto scena
Crea una scena istanziando la classe denominata Scene che appartiene al pacchetto javafx.scene. A questa classe, passa l'oggetto Group(root) creato nel passaggio precedente.
Oltre all'oggetto radice, puoi anche passare due parametri doppi che rappresentano l'altezza e la larghezza dello schermo insieme all'oggetto della classe Group come segue.
Scene scene = new Scene(group ,600, 300);
Passaggio 6: impostazione del titolo dello stage
Puoi impostare il titolo dello stage utilizzando il file setTitle() metodo del Stageclasse. IlprimaryStage è un oggetto Stage che viene passato al metodo di avvio della classe scene, come parametro.
Usando il primaryStage oggetto, imposta il titolo della scena come Sample Application come segue.
primaryStage.setTitle("Sample Application");
Passaggio 7: aggiunta della scena allo stage
Puoi aggiungere un oggetto Scene allo stage utilizzando il metodo setScene() della classe denominata Stage. Aggiungere l'oggetto Scene preparato nei passaggi precedenti utilizzando questo metodo come segue.
primaryStage.setScene(scene);
Passaggio 8: visualizzazione dei contenuti dello stage
Visualizza il contenuto della scena utilizzando il metodo denominato show() del Stage classe come segue.
primaryStage.show();
Passaggio 9: avvio dell'applicazione
Avvia l'applicazione JavaFX chiamando il metodo statico launch() del Application class dal metodo principale come segue.
public static void main(String args[]){
launch(args);
}
Esempio
Il seguente programma mostra come generare una linea retta utilizzando JavaFX. Salva questo codice in un file con il nomeJavafxSample.java.
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.shape.Line;
import javafx.stage.Stage;
public class DrawingLine extends Application{
@Override
public void start(Stage stage) {
//Creating a line object
Line line = new Line();
//Setting the properties to a line
line.setStartX(100.0);
line.setStartY(150.0);
line.setEndX(500.0);
line.setEndY(150.0);
//Creating a Group
Group root = new Group(line);
//Creating a Scene
Scene scene = new Scene(root, 600, 300);
//Setting title to the scene
stage.setTitle("Sample application");
//Adding the scene to the stage
stage.setScene(scene);
//Displaying the contents of a scene
stage.show();
}
public static void main(String args[]){
launch(args);
}
}
Compilare ed eseguire il file java salvato dal prompt dei comandi utilizzando i seguenti comandi.
javac DrawingLine.java
java DrawingLine
All'esecuzione, il programma di cui sopra genera una finestra JavaFX che mostra una linea retta come mostrato di seguito.
Esempio 3 - Visualizzazione di testo
Possiamo anche incorporare testo nella scena JavaFX. Questo esempio mostra come incorporare il testo in JavaFX.
Di seguito sono riportati i passaggi:
Passaggio 1: creazione di una classe
Crea una classe Java ed eredita il file Application classe del pacchetto javafx.application e implementare il start() metodo di questa classe come segue.
public class DrawingLine extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
}
}
Passaggio 2: incorporare il testo
Puoi incorporare testo in una scena JavaFX istanziando la classe denominata Text che appartiene a un pacchetto javafx.scene.shape, crea un'istanza di questa classe.
È possibile creare un'istanza di questa classe passando il testo da incorporare, in formato String. Oppure, è possibile creare un oggetto di testo utilizzando il costruttore predefinito come mostrato di seguito.
//Creating a Text object
Text text = new Text();
Passaggio 3: impostazione del carattere
È possibile impostare il carattere sul testo utilizzando il setFont() metodo del Textclasse. Questo metodo accetta un oggetto carattere come parametri. Imposta il carattere del testo dato su 45 come mostrato di seguito.
//Setting font to the text
text.setFont(new Font(45));
Passaggio 4: impostazione della posizione del testo
È possibile impostare la posizione del testo sul piano XY impostando le coordinate X, Y utilizzando i rispettivi metodi di impostazione setX() e setY() come segue.
//setting the position of the text
text.setX(50);
text.setY(150);
Passaggio 5: impostazione del testo da aggiungere
È possibile impostare il testo da aggiungere utilizzando il metodo setText () della classe Text. Questo metodo accetta un parametro stringa che rappresenta il testo da aggiungere.
text.setText("Welcome to Tutorialspoint");
Passaggio 6: creazione di un oggetto gruppo
Nel start() metodo, creare un oggetto gruppo istanziando la classe denominata Group, che appartiene al pacchetto javafx.scene.
Passa l'oggetto Text (nodo), creato nel passaggio precedente, come parametro al costruttore della classe Group, per aggiungerlo al gruppo come segue:
Group root = new Group(text)
Passaggio 7: creazione di un oggetto scena
Crea una scena istanziando la classe denominata Scene che appartiene al pacchetto javafx.scene. A questa classe, passa l'oggetto Group(root), creato nel passaggio precedente.
Oltre all'oggetto radice, puoi anche passare due parametri doppi che rappresentano l'altezza e la larghezza dello schermo insieme all'oggetto della classe Group come segue.
Scene scene = new Scene(group ,600, 300);
Passaggio 8: impostazione del titolo dello stage
Puoi impostare il titolo dello stage utilizzando il file setTitle() metodo del Stageclasse. IlprimaryStage è un oggetto Stage che viene passato al metodo di avvio della classe scene, come parametro.
Usando il primaryStage oggetto, imposta il titolo della scena come Sample Application come mostrato di seguito.
primaryStage.setTitle("Sample Application");
Passaggio 9: aggiunta di una scena allo stage
Puoi aggiungere un oggetto Scene allo stage utilizzando il metodo setScene() della classe denominata Stage. Aggiungere l'oggetto Scene preparato nei passaggi precedenti utilizzando questo metodo come segue.
primaryStage.setScene(scene);
Passaggio 10: visualizzazione dei contenuti dello stage
Visualizza il contenuto della scena utilizzando il metodo denominato show() del Stage classe come segue.
primaryStage.show();
Passaggio 11: avvio dell'applicazione
Avvia l'applicazione JavaFX chiamando il metodo statico launch() del Application class dal metodo principale come segue.
public static void main(String args[]){
launch(args);
}
Esempio
Di seguito è riportato il programma per visualizzare il testo utilizzando JavaFX. Salva questo codice in un file con nomeDisplayingText.java.
import javafx.application.Application;
import javafx.collections.ObservableList;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
public class DisplayingText extends Application {
@Override
public void start(Stage stage) {
//Creating a Text object
Text text = new Text();
//Setting font to the text
text.setFont(new Font(45));
//setting the position of the text
text.setX(50);
text.setY(150);
//Setting the text to be added.
text.setText("Welcome to Tutorialspoint");
//Creating a Group object
Group root = new Group();
//Retrieving the observable list object
ObservableList list = root.getChildren();
//Setting the text object as a node to the group object
list.add(text);
//Creating a scene object
Scene scene = new Scene(root, 600, 300);
//Setting title to the Stage
stage.setTitle("Sample Application");
//Adding scene to the stage
stage.setScene(scene);
//Displaying the contents of the stage
stage.show();
}
public static void main(String args[]){
launch(args);
}
}
Compilare ed eseguire il file java salvato dal prompt dei comandi utilizzando i seguenti comandi.
javac DisplayingText.java
java DisplayingText
All'esecuzione, il programma precedente genera una finestra JavaFX che mostra il testo come mostrato di seguito.