Panimula sa Java FX

Isang araw nagkaroon ako ng ideya na magsulat ng isang maliit na desktop application para sa aking mga pangangailangan - tulad ng isang maliit na diksyunaryo para sa pag-aaral ng mga banyagang salita - at sinimulan kong i-rack ang aking utak, paano ko ito magagawa? Natural, ang unang pumasok sa isip ko ay si Swing. Marahil ay narinig na ng lahat ang tungkol sa Swing . Ito ay isang library para sa paglikha ng user, mga graphical na interface. Dahil sa katotohanan na ang aming minamahal na Oracle ay hindi pa ganap na inabandona ang Swing, hindi ito itinuturing na lipas na, at ang mga aplikasyon ay tumatakbo pa rin dito. Gayunpaman, hindi na ito ginagawang moderno ng Swing, at binigyan kami ng mga tao sa Oracle ng panlasa kung ano ang kinabukasan ng JavaFX. At sa katunayan, ang JavaFX ay gumagamit ng mga bahagi ng Swing bilang isang service provider)

Ano ang JavaFX?

Ang JavaFX ay mahalagang isang toolkit ng GUI para sa Java. Magkakaroon ng maliit na digression dito, at maaalala natin kung ano ang GUI : Graphical user interface - isang graphical user interface ay isang uri ng user interface kung saan ang lahat ng elemento (buttons, menu, icon, list) ay ipinakita sa user sa ang display ay ginawa sa anyo ng mga larawan, graphics . Hindi tulad ng interface ng command line, sa isang GUI ang user ay may random na access sa mga nakikitang bagay gamit ang mga input device. Kadalasan, ang mga elemento ng interface ay ipinapatupad sa anyo ng mga metapora at ipinapakita ang kanilang mga katangian at layunin upang mapadali ang pag-unawa ng gumagamit. Ang JavaFX ay naglalayong lumikha ng mga laro at desktop application sa Java. Sa katunayan, papalitan nito ang Swing dahil sa iminungkahing bagong GUI tool para sa Java. Gayundin, binibigyang-daan kami nitong mag-istilo ng mga file ng layout ng GUI (XML) at gawing mas elegante ang mga ito gamit ang CSS, katulad ng nakasanayan namin sa mga web application. Bukod dito, pinangangasiwaan ng JavaFX ang pinagsama-samang 3D graphics pati na rin ang audio, video at mga naka-embed na networking application sa isang toolkit ng GUI... Madali itong matutunan at mahusay na na-optimize. Sinusuportahan nito ang maraming operating system, pati na rin ang Windows, UNIX system at Mac OS.

Mga Tampok ng JavaFX:

• Ang JavaFX sa una ay may kasamang malaking hanay ng mga bahagi ng graphical na interface, tulad ng lahat ng uri ng mga button, text field, talahanayan, puno, menu, chart, atbp., na kung saan ay makakatipid sa amin ng maraming oras.
• Ang JavaFX ay madalas na gumagamit ng mga estilo ng CSS, at magagamit namin ang isang espesyal na format ng FXML upang lumikha ng GUI, sa halip na gawin ito sa Java code. Pinapadali nitong mabilis na maglatag ng GUI o baguhin ang hitsura o komposisyon nang hindi kinakailangang maglaro sa Java code nang mahabang panahon.
• Ang JavaFX ay may handa nang gamitin na mga bahagi ng diagram kaya hindi namin kailangang isulat ang mga ito mula sa simula anumang oras na kailangan mo ng pangunahing diagram.
• Ang JavaFX ay mayroon ding suporta sa 3D graphics, na kadalasang kapaki-pakinabang kung bubuo tayo ng ilang uri ng laro o katulad na mga application.

Tingnan natin ang mga pangunahing bahagi ng aming window:

• Ang entablado ay isang nakapalibot na window na nagsisilbing panimulang canvas at naglalaman ng iba pang bahagi. Ang isang application ay maaaring magkaroon ng ilang mga yugto, ngunit sa anumang kaso dapat mayroong isang tulad na bahagi. Sa esensya, ang Stage ang pangunahing lalagyan at entry point.
• Eksena - ipinapakita ang mga nilalaman ng entablado (tulad ng isang pugad na manika). Ang bawat yugto ay maaaring maglaman ng ilang mga bahagi - eksena, na maaaring ilipat sa kanilang mga sarili. Sa panloob, ito ay ipinatupad ng isang object graph na tinatawag na Scene Graph (kung saan ang bawat elemento ay isang node, tinatawag ding Node ).
• Ang mga node ay mga kontrol, gaya ng mga button ng label, o kahit na mga layout, na maaaring magkaroon ng maraming nested na bahagi sa loob ng mga ito. Ang bawat eksena ay maaaring magkaroon ng isang nested node, ngunit maaari itong maging isang layout na may maraming bahagi. Maaaring multi-level ang nesting, na may mga layout na naglalaman ng iba pang mga layout at regular na bahagi. Ang bawat naturang node ay may sariling identifier, istilo, epekto, estado, at mga tagapangasiwa ng kaganapan.

Kaya't lumipat tayo ng kaunti patungo sa code. Dahil gumagamit ako ng Java 8, hindi ko na kailangang mag-pull up ng anumang dependencies, dahil ang JavaFx ay nasa JDK bilang default (tulad ng sa Java 9.10), ngunit kung mayroon tayong Java 11+, kailangan nating pumunta sa maven repository at hilahin ito mula doon dependencies.

JavaFX: mga halimbawa ng paggamit

Lumilikha kami ng isang regular na klase na may isang pamamaraan main(entry point):

public class AppFX extends Application {

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

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

Dito nagmana ang aming klase javafx.application.Application(na mayroon kami sa kahon ng Bugaga). Sa pangunahing tinatawag namin ang static na paraan ng Application launch()upang ilunsad ang aming window. Gayundin, magrereklamo ang aming ideya na hindi namin ipinatupad ang paraan ng Application, startna sa huli ay ginagawa namin. Para saan ito? At upang mapangasiwaan ang mga katangian (ang pag-andar ng aming window). Upang gawin ito, gumagamit kami ng isang papasok na argumento primaryStagekung saan tinatawag namin ang isang paraan showupang makita namin ang window na inilulunsad sa main. Punan natin ng kaunti ang aming pamamaraan 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();
}

Kaya ano ang nakikita natin dito? Dumaan tayo sa linya sa pamamagitan ng linya: 2 - itakda ang pangalan ng window mismo (yugto) 3.4 - itakda ang mga sukat nito 6.7 - itakda ang landas ng stream ng pagbabasa sa file (icon) 8 - lumikha ng file bilang isang object ng imahe, na konektado sa totoong file ng stream na ipinasa sa constructor 9 - magtakda ng icon sa tuktok na panel ng window 11 - lumikha ng isang bagay na pindutan 13-16 - itakda ang reaksyon kapag pinindot ang pindutan 17 - lumikha ng isang eksena kung saan inilalagay namin ang aming button 18 - ilagay ang eksena sa aming karaniwang window 20 - itakda ang visibility flag para sa window At bilang isang resulta nakakakuha kami ng isang maliit na window upang salubungin ang aming mga paboritong pesels: Ang lahat ay mukhang mas simple kaysa sa Swing, hindi ba? Pero hindi pa tapos. Hindi magandang isulat ang lahat ng code upang ipakita ang isang application; kailangan mong hatiin ito kahit papaano upang gawin itong mas maliwanag (mga graphical na bahagi sa isang basket, lohika sa isa pa). At dito dumating ang xml sa larawan... Diyos ko, xml? Eksakto. Sa partikular, ginagamit namin ang partikular na pagpapatupad nito para sa JavaFX - FXML, kung saan tinutukoy namin ang mga graphical na bahagi ng application at ang mga katangian ng mga ito (lahat ng uri ng laki, atbp.), at pagkatapos ay ikonekta ito sa isang controller, na tumutulong na pamahalaan ang lohika. Tingnan natin ang isang halimbawa ng xml na ito:

<?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 - ang scripting language na ginagamit namin 4-6 - na-import na data 8-9 Vbox - isang container na naglalagay ng mga subcomponents sa isang linya. 11 - ipakita ang ilang teksto 13 - isang pindutan, kapag na-click, ginagamit namin ang pamamaraang inilarawan sa script sa mga linya 15-18. Dapat mayroong code para sa pagtawag sa xml file na ito sa pamamaraan start, ngunit ngayon ay hindi na ito napakahalaga, at kami ay aalisin ito (sa ibaba ay magkakaroon ng isang halimbawa ng paghila ng file na ito). Kaya, ang xml ay, siyempre, mabuti (ngunit hindi napakahusay), ang pagsusulat ng mga ito nang manu-mano ay lubhang nakalilito, hindi ba ito ang huling siglo?

Ipinapakilala ang JavaFX SceneBuilder

Sa puntong ito na ang (drum roll) ay naglaro - SceneBuilder Sa JavaFX Scene Builder ay isang tool kung saan maaari naming idisenyo ang aming mga bintana sa anyo ng isang graphical na interface at pagkatapos ay i-save ang mga ito, at ang program na ito, batay sa resulta, ay bumuo ng mga xml na file na pagbutihin namin ito sa aming aplikasyon. Ang interface ng tagabuo ng fmxl na ito ay mukhang ganito:

Isang maliit na digression. Mga aralin sa JavaFX

Laktawan ko ang mga detalye ng pag-install, at isang detalyadong pag-aaral din ng tool na ito. Ang mga ito ay mga paksang nagkakahalaga ng pagtuklas pa. Samakatuwid, mag-iiwan pa rin ako ng ilang kawili-wiling link sa mga aralin sa JavaFX: isa (online na tutorial sa JavaFX) at dalawa (isa pang magandang tutorial). Patakbuhin natin ang isang maliit na halimbawa na aking sketch out. Sa huli nakakuha ako ng isang bagay tulad ng: (parang isang window para sa pagpaparehistro ng mga aso) Kapag pumili ka ng aso at pinindot ang Delete button, aalisin ang aso sa aming listahan. Kapag pumili ka ng isang kaibigang may apat na paa at binago ang mga field nito, at pagkatapos pindutin ang pindutang I-edit, ina-update ang impormasyon ng aso. Kapag pinindot namin ang New button, may lalabas na window para gumawa ng record para sa isang bagong aso (upang magsimula sa pangalan nito): Pagkatapos ay i-click ang I-save at punan ang natitirang mga field nito sa unang window, at pagkatapos ay i-click ang Edit button upang iligtas. Mukhang madali, tama? Tingnan natin kung ano ang magiging hitsura nito sa aming Java application. Upang magsimula, iiwan ko lang dito ang mga xml na layout para sa dalawang window na ito na nabuo sa SceneBuilder: Una (basic):

<?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>

Pangalawa (upang lumikha ng mga bagong doggies):

<?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>

Ano ang hitsura ng istraktura ng folder: Tulad ng nakikita mo, walang espesyal, may mga controller na kumakatawan sa ilang mga window, may mga modelo na kumakatawan sa aming data. Tingnan natin ang klase na naglulunsad ng application (Pagpapatupad ng application): @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));
    }

Dito makikita natin ang isang constructor na pupunuin ang ating paunang data (na iniimbak natin sa isang espesyal na sheet - 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();
}

Walang espesyal - mainat ang pagpapatupad start()na naglulunsad ng application:

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();
        }
    }

Kaya, dito nakikita namin ang paraan na aktwal naming inilunsad sa start(), ibig sabihin, ang isa na nagtatakda ng mga setting ng aming base window. Tulad ng sa xml layout sa mga mapagkukunan: pagbibigay dito ng icon, pag-link nito sa isang partikular na controller, at pagbibigay sa controller ng link sa thisklase)

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();
        }
    }
}

Dito makikita natin ang paraan na responsable para sa hitsura ng pangalawang window - ang window para sa paglikha ng isang bagong tala (ang pangalan ng isang bagong aso). Itinakda din namin ang controller, xml layout, stage, atbp... Ang susunod na klase na aming isasaalang-alang ay isang modelo na kumakatawan sa aming aso (impormasyon tungkol dito): @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;
    }
}

Dito nakikita natin ang dalawang constructor. Ang isa ay halos regular na may lahat ng argumento (halos, dahil gumagamit kami ng mga espesyal na FX wrapper ng mga simpleng uri) at isang constructor na walang argumento: ginagamit namin ito kapag gumagawa ng bagong aso, na sa una ay mayroon lamang pangalan. Controller para sa pangunahing window: @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;

Dito makikita natin ang ating mga object field, ngunit nasa TextField na format. Ito ay isang format na kumakatawan sa isang field ng text input. Ang @FXML ay isang anotasyon na idinisenyo upang i-link ang Java code at ang kaukulang bagay ng aming layout (button, field, o iba pa).

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

Dito makikita natin ang isang paraan para sa pagpapakita ng mga pangalan ng aso, sa kanan sa listahan (ang @FXML annotation nito ay nagbubuklod sa bahagi ng layout ng 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("");
    }
}

Sa unang paraan makikita natin ang pagtatakda ng panloob na sanggunian sa klase na nagpapatupad ng Application (upang matatawag natin ang pamamaraan nito para tawagan ang pangalawang window), at itakda ang unang listahan na ipapakita. Sinusuri ng pangalawa kung ang kasalukuyang aso ay may ilang partikular na data, at batay dito ay nagtatakda ng mga patlang ng teksto:

@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);
        }
    }
}

Dito makikita natin ang tatlong paraan ng base window na nauugnay sa mga pindutan:

• tanggalin - tanggalin ang napiling (napiling) aso sa pamamagitan ng index;
• i-edit - lumikha ng isang bagong aso na may inilipat na data, at itakda ito sa halip na ang nauna;
• lumikha - lumikha kami ng isang bagong aso at tinawag ang paraan ng pagtawag sa window ng paglikha, pagpasa ng isang bagong bagay, at pagkatapos isara kung saan, kung ang pangalan ay hindi null, pagkatapos ay i-save ang bagong alagang hayop.

Sa paglipat, ang window controller para sa paglikha ng aso: @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();
    }
}

Dito nakikita natin ang koneksyon sa field ng teksto sa window, pinoproseso ang mga pindutan ng I-save at Kanselahin, na kahit papaano ay nagsasara ng window. Tulad ng nakikita mo, para sa higit na kaginhawahan sa aking maliit na application ay ginamit ko ang Lombok, kung hindi, ang code ay lalago nang husto, at hindi ko ito akma sa aking pagsusuri. Yun lang siguro ang meron ako ngayon. Ngayon ay nakilala namin sandali ang mga pangunahing konsepto at isang halimbawa ng paggamit ng JavaFX, at maaari kaming bumuo ng maliliit na desktop application (gamit ang karagdagang impormasyon, na, sa kabutihang palad, ay sagana sa Internet). At ikaw naman, gusto))