Pengantar Java FX

Suatu hari saya mendapat ide untuk menulis aplikasi desktop kecil untuk kebutuhan saya - seperti kamus kecil untuk mempelajari kata-kata asing - dan saya mulai memutar otak, bagaimana saya bisa melakukan ini? Tentu saja, hal pertama yang terlintas di benak saya adalah Swing. Semua orang mungkin pernah mendengar tentang Swing . Ini adalah perpustakaan untuk membuat antarmuka pengguna dan grafis. Karena fakta bahwa Oracle kesayangan kita belum sepenuhnya meninggalkan Swing, Swing tidak dianggap ketinggalan jaman, dan aplikasi masih berjalan di dalamnya. Namun, JavaFX tidak lagi dimodernisasi oleh Swing, dan orang-orang di Oracle telah memberi kita gambaran tentang masa depan JavaFX. Dan faktanya, JavaFX menggunakan komponen Swing sebagai penyedia layanan)

Apa itu JavaFX?

JavaFX pada dasarnya adalah toolkit GUI untuk Java. Akan ada penyimpangan kecil di sini, dan kita akan mengingat apa itu GUI : Antarmuka pengguna grafis - antarmuka pengguna grafis adalah jenis antarmuka pengguna di mana semua elemen (tombol, menu, ikon, daftar) disajikan kepada pengguna di Tampilan dibuat dalam bentuk gambar, grafik. Berbeda dengan antarmuka baris perintah, di GUI pengguna memiliki akses acak ke objek yang terlihat menggunakan perangkat input. Seringkali, elemen antarmuka diimplementasikan dalam bentuk metafora dan menampilkan properti serta tujuannya untuk memudahkan pemahaman pengguna. JavaFX ditujukan untuk membuat game dan aplikasi desktop di Java. Faktanya, ini akan menggantikan Swing karena alat GUI baru yang diusulkan untuk Java. Selain itu, ini memungkinkan kita menata file tata letak GUI (XML) dan membuatnya lebih elegan menggunakan CSS, mirip dengan yang biasa kita gunakan dalam aplikasi web. JavaFX juga menangani grafik 3D terintegrasi serta audio, video dan aplikasi jaringan tertanam dalam satu perangkat GUI... Mudah dipelajari dan dioptimalkan dengan baik. Ini mendukung banyak sistem operasi, serta Windows, sistem UNIX dan Mac OS.

Fitur JavaFX:

• JavaFX awalnya hadir dengan sekumpulan besar bagian antarmuka grafis, seperti semua jenis tombol, bidang teks, tabel, pohon, menu, bagan, dll., yang pada gilirannya akan menghemat banyak waktu kita.
• JavaFX sering kali menggunakan gaya CSS, dan kita dapat menggunakan format FXML khusus untuk membuat GUI, daripada melakukannya dalam kode Java. Hal ini memudahkan untuk menata GUI dengan cepat atau mengubah tampilan atau komposisi tanpa harus bermain-main dengan kode Java dalam waktu lama.
• JavaFX memiliki bagian diagram yang siap digunakan sehingga kita tidak perlu menulisnya dari awal kapan pun Anda memerlukan diagram dasar.
• JavaFX juga hadir dengan dukungan grafis 3D, yang seringkali berguna jika kita sedang mengembangkan suatu jenis game atau aplikasi serupa.

Mari kita lihat sedikit komponen utama jendela kita:

• Panggung pada dasarnya adalah jendela sekeliling yang bertindak sebagai kanvas awal dan berisi komponen lainnya. Sebuah aplikasi dapat memiliki beberapa tahapan, tetapi bagaimanapun juga harus ada satu komponen tersebut. Intinya, Panggung adalah wadah utama dan pintu masuk.
• Scene - menampilkan isi panggung (seperti boneka bersarang). Setiap tahapan dapat berisi beberapa komponen – adegan, yang dapat dialihkan satu sama lain. Secara internal, hal ini diimplementasikan oleh grafik objek yang disebut Scene Graph (yang setiap elemennya adalah node, disebut juga Node ).
• Node adalah kontrol, seperti tombol label, atau bahkan tata letak, yang dapat memiliki beberapa komponen bertingkat di dalamnya. Setiap adegan dapat memiliki satu simpul bersarang, namun dapat juga berupa tata letak dengan beberapa komponen. Penyusunan bisa bertingkat, dengan tata letak yang berisi tata letak lain dan komponen reguler. Setiap node tersebut memiliki pengidentifikasi, gaya, efek, status, dan pengendali kejadiannya sendiri.

Jadi mari kita beralih sedikit ke arah kode. Karena saya menggunakan Java 8, saya tidak perlu mengambil dependensi apa pun, karena JavaFx ada di JDK secara default (seperti di Java 9.10), tetapi jika kita memiliki Java 11+, maka kita perlu pergi ke repositori maven dan tarik dari sana ketergantungan.

JavaFX: contoh penggunaan

Kami membuat kelas reguler dengan metode main(titik masuk):

public class AppFX extends Application {

    public static void main(String[] args) {
        Application.launch();
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
pimarySatge.show();
    }
}

Di sini kelas kita mewarisi javafx.application.Application(yang kita dapatkan dari kotak Bugaga). Di main kami memanggil metode Aplikasi statis launch()untuk meluncurkan jendela kami. Selain itu, ide kami akan mengeluh karena kami belum menerapkan metode Aplikasi, startyang pada akhirnya kami lakukan. Untuk apa? Dan untuk dapat mengelola properti (fungsi jendela kita). Untuk melakukan ini, kita menggunakan argumen masuk primaryStageyang kita sebut metode showsehingga kita dapat melihat jendela diluncurkan di main. Mari kita isi sedikit metode kita start:

public void start(Stage primaryStage) throws Exception {
    primaryStage.setTitle("Dogs application");
    primaryStage.setWidth(500);
    primaryStage.setHeight(400);

    InputStream iconStream =
    getClass().getResourceAsStream("/images/someImage.png");
    Image image = new Image(iconStream);
    primaryStage.getIcons().add(image);

    Button button = new Button("WOF WOF ???'");

    button.setOnAction(e -< {
      Alert alert = new Alert(Alert.AlertType.INFORMATION, "WOF WOF WOF!!!");
        alert.showAndWait();
    });
    Scene primaryScene = new Scene(button);
    primaryStage.setScene(primaryScene);

    primaryStage.show();
}

Jadi apa yang kita lihat di sini? Mari kita lalui baris demi baris: 2 - atur nama jendela itu sendiri (tahap) 3.4 - atur dimensinya 6.7 - atur jalur aliran pembacaan ke file (ikon) 8 - buat file sebagai objek Gambar, yang terhubung ke file sebenarnya melalui aliran yang diteruskan di konstruktor 9 - atur ikon di panel atas jendela 11 - buat objek tombol 13-16 - atur reaksi saat tombol ditekan 17 - buat adegan di mana kita tempatkan tombol kita 18 - tempatkan adegan pada jendela umum kita 20 - atur bendera visibilitas untuk jendela Dan sebagai hasilnya kita mendapatkan jendela kecil untuk menyambut pesel favorit kita: Semuanya terlihat jauh lebih sederhana daripada Swing, bukan? Tapi ini belum berakhir. Tidak baik menulis semua kode untuk menampilkan aplikasi; Anda perlu membaginya agar lebih mudah dipahami (komponen grafis di satu keranjang, logika di keranjang lain). Dan di sini xml muncul... Ya Tuhan, xml? Tepat. Secara khusus, kami menggunakan implementasi spesifiknya untuk JavaFX - FXML, di mana kami mendefinisikan komponen grafis aplikasi dan propertinya (segala jenis ukuran, dll.), lalu menghubungkannya ke pengontrol, yang membantu mengelola logika. Mari kita lihat contoh xml ini:

<?xml version="1.0" encoding="UTF-8"?>
<?language javascript?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.VBox?>

<VBox xmlns="http://javafx.com/javafx"  xmlns:fx="http://javafx.com/fxml"
   id="Dogs application" prefHeight="200" prefWidth="300" alignment="center">

  <Label text="Wow wow?"/>

  <Button fx:id="mainButton" text="Greeting" onAction="buttonClicked()"/>

    <fx:script>
       function buttonClicked() {
            mainButton.setText("Wow wow wow!!!")
       }
    </fx:script>
</VBox>

2 - bahasa scripting yang kami gunakan 4-6 - data yang diimpor 8-9 Vbox - wadah yang menempatkan subkomponen dalam satu baris. 11 - menampilkan beberapa teks 13 - sebuah tombol, ketika diklik, kami menggunakan metode yang dijelaskan dalam skrip pada baris 15-18. Seharusnya ada kode untuk memanggil file xml ini dalam metode tersebut start, tetapi sekarang ini tidak begitu penting, dan kami akan menghilangkannya (di bawah akan ada contoh menarik file ini). Jadi xml tentu saja bagus (tapi tidak terlalu bagus), menulisnya secara manual sangat membingungkan, bukankah ini abad terakhir?

Memperkenalkan JavaFX SceneBuilder

Pada titik inilah (drum roll) mulai berperan - SceneBuilder Dalam JavaFX Scene Builder adalah alat yang dengannya kita dapat mendesain jendela kita dalam bentuk antarmuka grafis dan kemudian menyimpannya, dan program ini, berdasarkan hasilnya, akan buat file xml yang akan kami perbaiki di aplikasi kami. Antarmuka pembuat fmxl ini terlihat seperti ini:

Penyimpangan kecil. Pelajaran JavaFX

Saya akan melewatkan detail instalasi, dan studi mendetail tentang alat ini juga. Ini adalah topik yang perlu ditelusuri lebih lanjut. Oleh karena itu, saya akan tetap meninggalkan beberapa link menarik ke pelajaran JavaFX: satu (tutorial online tentang JavaFX) dan dua (tutorial bagus lainnya). Mari kita lihat contoh kecil yang saya buat sketsa. Pada akhirnya saya mendapatkan sesuatu seperti: (semacam jendela untuk mendaftarkan anjing) Saat Anda memilih seekor anjing dan menekan tombol Hapus, anjing tersebut akan dihapus dari daftar kami. Saat Anda memilih teman berkaki empat dan mengubah bidangnya, dan setelah menekan tombol Edit, informasi anjing tersebut diperbarui. Ketika kita menekan tombol Baru, sebuah jendela muncul untuk membuat catatan untuk seekor anjing baru (untuk memulai dengan namanya): Kemudian klik Simpan dan isi sisa kolomnya di jendela pertama, lalu klik tombol Edit untuk menyimpan. Kedengarannya mudah, bukan? Mari kita lihat tampilannya di aplikasi Java kita. Untuk memulainya, saya akan meninggalkan di sini tata letak xml untuk dua jendela ini yang dihasilkan di SceneBuilder: Pertama (dasar):

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.SplitPane?>
<?import javafx.scene.control.TableColumn?>
<?import javafx.scene.control.TableView?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.ColumnConstraints?>
<?import javafx.scene.layout.GridPane?>
<?import javafx.scene.layout.RowConstraints?>
<AnchorPane prefHeight="300.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.tutorial.controller.BaseController">
   <children>
      <SplitPane dividerPositions="0.29797979797979796" prefHeight="300.0" prefWidth="600.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
        <items>
          <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="160.0" prefWidth="100.0">
               <children>
                  <TableView fx:id="dogs" layoutX="-2.0" layoutY="-4.0" prefHeight="307.0" prefWidth="190.0" AnchorPane.bottomAnchor="-5.0" AnchorPane.leftAnchor="-2.0" AnchorPane.rightAnchor="-13.0" AnchorPane.topAnchor="-4.0">
                    <columns>
                      <TableColumn fx:id="nameList" prefWidth="100.33334350585938" text="Nickname" />
                    </columns>
                     <columnResizePolicy>
                        <TableView fx:constant="CONSTRAINED_RESIZE_POLICY" />
                     </columnResizePolicy>
                  </TableView>
               </children>
            </AnchorPane>
          <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="160.0" prefWidth="100.0">
               <children>
                  <Label layoutX="49.0" layoutY="25.0" text="Person Details" AnchorPane.leftAnchor="5.0" AnchorPane.topAnchor="5.0" />
                  <GridPane accessibleText="erreererer" gridLinesVisible="true" layoutX="5.0" layoutY="31.0" AnchorPane.leftAnchor="5.0" AnchorPane.rightAnchor="5.0" AnchorPane.topAnchor="31.0">
                    <columnConstraints>
                      <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                      <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                    </columnConstraints>
                    <rowConstraints>
                      <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                      <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                        <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                        <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                      <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                    </rowConstraints>
                     <children>
                        <Label prefHeight="17.0" prefWidth="70.0" text="Nickname" />
                        <Label text="Breed" GridPane.rowIndex="1" />
                        <Label text="Age" GridPane.rowIndex="2" />
                        <Label text="City" GridPane.rowIndex="3" />
                        <Label text="Level of training" GridPane.rowIndex="4" />
                        <TextField fx:id="breed" GridPane.columnIndex="1" GridPane.rowIndex="1" />
                        <TextField fx:id="age" GridPane.columnIndex="1" GridPane.rowIndex="2" />
                        <TextField fx:id="city" GridPane.columnIndex="1" GridPane.rowIndex="3" />
                        <TextField fx:id="levelOfTraining" GridPane.columnIndex="1" GridPane.rowIndex="4" />
                        <TextField fx:id="name" GridPane.columnIndex="1" />
                     </children>
                  </GridPane>
                  <Button layoutX="251.0" layoutY="259.0" mnemonicParsing="false" onAction="#create" text="New" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="230.0" AnchorPane.rightAnchor="130.0" AnchorPane.topAnchor="260.0" />
                  <Button layoutX="316.0" layoutY="262.0" mnemonicParsing="false" onAction="#edit" text="Edit" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="290.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="260.0" />
                  <Button layoutX="360.0" layoutY="262.0" mnemonicParsing="false" onAction="#delete" text="Delete" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="350.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="260.0" />
               </children>
            </AnchorPane>
        </items>
      </SplitPane>
   </children>
</AnchorPane>

Kedua (untuk membuat anjing baru):

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.ColumnConstraints?>
<?import javafx.scene.layout.GridPane?>
<?import javafx.scene.layout.RowConstraints?>
<?import javafx.scene.text.Font?>
<AnchorPane prefHeight="200.0" prefWidth="300.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.tutorial.controller.NewDogController">
   <children>
      <GridPane layoutX="31.0" layoutY="25.0" prefHeight="122.0" prefWidth="412.0">
        <columnConstraints>
          <ColumnConstraints hgrow="SOMETIMES" maxWidth="185.0" minWidth="10.0" prefWidth="149.0" />
          <ColumnConstraints hgrow="SOMETIMES" maxWidth="173.0" minWidth="10.0" prefWidth="146.0" />
        </columnConstraints>
        <rowConstraints>
          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
        </rowConstraints>
         <children>
            <Label prefHeight="48.0" prefWidth="178.0" text="Please, write name:">
               <font>
                  <Font size="20.0" />
               </font>
            </Label>
            <TextField fx:id="nickName" prefHeight="36.0" prefWidth="173.0" GridPane.columnIndex="1" />
         </children>
      </GridPane>
      <Button layoutX="222.0" layoutY="149.0" mnemonicParsing="false" onAction="#ok" prefHeight="37.0" prefWidth="95.0" text="Save" />
      <Button layoutX="325.0" layoutY="149.0" mnemonicParsing="false" onAction="#cansel" prefHeight="37.0" prefWidth="95.0" text="Cansel" />
   </children>
</AnchorPane>

Seperti apa struktur foldernya: Seperti yang Anda lihat, tidak ada yang istimewa, ada pengontrol yang mewakili jendela tertentu, ada model yang mewakili data kami. Mari kita lihat kelas yang meluncurkan aplikasi (Implementasi aplikasi): @Data

public class AppFX extends Application {

    private Stage primaryStage;
    private AnchorPane rootLayout;
    private ObservableList listDog = FXCollections.observableArrayList();

    public AppFX() {
        listDog.add(new Dog("Fluffy", "Pug", 8, "Odessa", 2));
        listDog.add(new Dog("Archie", "Poodle", 3, "Lviv", 6));
        listDog.add(new Dog("Willie", "Bulldog", 5, "Kiev", 4));
        listDog.add(new Dog("Hector", "Shepherd", 9, "Minsk", 6));
        listDog.add(new Dog("Duncan", "Dachshund", 1, "Hogwarts", 9));
    }

Di sini kita melihat konstruktor yang akan mengisi data awal kita (yang kita simpan di lembar khusus - ObservableList).

public static void main(String[] args) {
        Application.launch();
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
        this.primaryStage = primaryStage;
        this.primaryStage.setTitle("Dogs application");
        showBaseWindow();
}

Tidak ada yang istimewa - maindan implementasi start()yang meluncurkan aplikasi:

public void showBaseWindow() {
        try {
            FXMLLoader loader = new FXMLLoader();
            loader.setLocation(AppFX.class.getResource("/maket/rootWindow.fxml"));
            rootLayout = loader.load();
            Scene scene = new Scene(rootLayout);
            primaryStage.setScene(scene);
            InputStream iconStream = getClass().getResourceAsStream("/icons/someImage.png");
            Image image = new Image(iconStream);
            primaryStage.getIcons().add(image);
            BaseController controller = loader.getController();
            controller.setAppFX(this);
            primaryStage.show();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Jadi, di sini kita melihat metode yang sebenarnya kita luncurkan start(), yaitu metode yang mengatur pengaturan jendela dasar kita. Seperti dalam tata letak xml di sumber daya: memberinya ikon, menghubungkannya ke pengontrol tertentu, dan memberikan tautan ke thiskelas kepada pengontrol)

public void showCreateWindow(Dog dog) {
        try {
            FXMLLoader loader = new FXMLLoader();
            loader.setLocation(AppFX.class.getResource("/maket/new.fxml"));
            AnchorPane page = loader.load();
            Stage dialogStage = new Stage();
            dialogStage.setTitle("Wow Wow Wow");
            dialogStage.initModality(Modality.WINDOW_MODAL);
            dialogStage.initOwner(primaryStage);
            dialogStage.setScene(new Scene(page));
            CreateController controller = loader.getController();
            controller.setDialogStage(dialogStage);
            controller.setDog(dog);
            dialogStage.showAndWait();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Di sini kita melihat metode yang bertanggung jawab atas tampilan jendela kedua - jendela untuk membuat catatan baru (nama anjing baru). Kami juga mengatur pengontrol, tata letak xml, panggung, dll... Kelas berikutnya yang akan kami pertimbangkan adalah model yang mewakili anjing kami (informasi tentangnya): @Data

public class Dog {

    private StringProperty name;
    private StringProperty breed;
    private IntegerProperty age;
    private StringProperty city;
    private IntegerProperty levelOfTraining;

    public Dog(String name, String breed, int age, String city, int levelOfTraining) {
        this.name = new SimpleStringProperty(name);
        this.breed = new SimpleStringProperty(breed);
        this.age = new SimpleIntegerProperty(age);
        this.city = new SimpleStringProperty(city);
        this.levelOfTraining = new SimpleIntegerProperty(levelOfTraining);
    }

    public Dog() {
        name = new SimpleStringProperty();
        breed = null;
        age = null;
        city = null;
        levelOfTraining = null;
    }
}

Di sini kita melihat dua konstruktor. Yang satu hampir biasa dengan semua argumen (hampir, karena kita menggunakan pembungkus FX khusus tipe sederhana) dan konstruktor tanpa argumen: kita menggunakannya saat membuat anjing baru, yang pada awalnya hanya memiliki sebuah nama. Pengontrol untuk jendela dasar: @Data

public class BaseController {

    @FXML
    private TableView dogs;
    @FXML
    private TableColumn nameList;
    @FXML
    private TextField name;
    @FXML
    private TextField breed;
    @FXML
    private TextField age;
    @FXML
    private TextField city;
    @FXML
    private TextField levelOfTraining;
    private AppFX appFX;

Di sini kita melihat bidang objek kita, tetapi dalam format TextField. Ini adalah format yang mewakili kolom input teks. @FXML adalah anotasi yang dirancang untuk menghubungkan kode Java dan objek terkait tata letak kita (tombol, bidang, atau yang lainnya).

@FXML
private void initialize() {
    nameList.setCellValueFactory(
            cellData -> cellData.getValue().getName());
    dogs.getSelectionModel().selectedItemProperty().addListener(
            (observable, oldValue, newValue) -> showDogsInformation(newValue));
}

Di sini kita melihat metode untuk menampilkan nama anjing, di sebelah kanan daftar (anotasi @FXML-nya mengikat komponen tata letak JavaFX TableView).

public void setAppFX(AppFX appFX) {
    this.appFX = appFX;
    dogs.setItems(appFX.getListDog());
}

private void showDogsInformation(Dog dog) {
    if (dog != null) {
        name.setText(dog.getName() != null ? dog.getName().getValue() : null);
        breed.setText(dog.getBreed() != null ? dog.getBreed().getValue() : null);
        age.setText(dog.getAge() != null ? String.valueOf(dog.getAge().get()) : null);
        city.setText(dog.getCity() != null ? dog.getCity().getValue() : null);
        levelOfTraining.setText(dog.getLevelOfTraining() != null ? String.valueOf(dog.getLevelOfTraining().get()) : null);
    } else {
        name.setText("");
        breed.setText("");
        age.setText("");
        city.setText("");
        levelOfTraining.setText("");
    }
}

Dalam metode pertama kita melihat pengaturan referensi internal ke kelas yang mengimplementasikan Aplikasi (sehingga kita dapat memanggil metodenya untuk memanggil jendela kedua), dan mengatur daftar awal yang akan ditampilkan. Yang kedua memeriksa apakah anjing saat ini memiliki data tertentu, dan berdasarkan ini, setel kolom teks:

@FXML
    private void delete() {
        int selectedIndex = dogs.getSelectionModel().getSelectedIndex();
        dogs.getItems().remove(selectedIndex);
    }

    @FXML
    private void edit() {
        int selectedIndex = dogs.getSelectionModel().getSelectedIndex();
        dogs.getItems().set(selectedIndex, new Dog(name.getText(), breed.getText(), Integer.valueOf(age.getText()), city.getText(), Integer.valueOf(levelOfTraining.getText())));
    }

    @FXML
    private void create() {
        Dog someDog = new Dog();
        appFX.showCreateWindow(someDog);
        if (someDog.getName() != null && !someDog.getName().getValue().isEmpty()) {
            appFX.getListDog().add(someDog);
        }
    }
}

Di sini kita melihat tiga metode jendela dasar yang terkait dengan tombol:

• delete — menghapus anjing yang dipilih (dipilih) berdasarkan indeks;
• edit - buat anjing baru dengan data yang ditransfer, dan atur bukan yang sebelumnya;
• buat - kita membuat anjing baru dan memanggil metode memanggil jendela pembuatan, meneruskan objek baru, dan setelah menutupnya, jika namanya bukan nol, simpan hewan peliharaan baru.

Selanjutnya, pengontrol jendela untuk membuat anjing: @Data

public class CreateController {
    private Stage dialogStage;
    private Dog dog;

    @FXML
    private TextField nickName;

    @FXML
    private void ok() {
        if (nickName != null && !nickName.getText().isEmpty()) {
            dog.setName(new SimpleStringProperty(nickName.getText()));
            dialogStage.close();
        }
    }

    @FXML
    private void cansel() {
        dialogStage.close();
    }
}

Di sini kita melihat koneksi dengan bidang teks di jendela, memproses tombol Simpan dan Batal, yang entah bagaimana menutup jendela. Seperti yang Anda lihat, untuk kenyamanan lebih dalam aplikasi kecil saya, saya menggunakan Lombok, jika tidak, kodenya akan bertambah banyak dan saya tidak akan memasukkannya ke dalam ulasan saya. Mungkin hanya itu yang saya punya untuk hari ini. Hari ini kita berkenalan secara singkat dengan konsep dasar dan contoh penggunaan JavaFX, dan kita dapat membangun aplikasi desktop kecil (menggunakan informasi tambahan, yang untungnya banyak tersedia di Internet). Dan Anda, pada gilirannya, menyukainya))