Installing the JDK on Microsoft Windows

The following steps use the Java 9 JDK 64-bit version for the Windows 10 operating system. If your Windows operating system is different, refer to the following link for further details.

http://www.oracle.com/technetwork/java/javase/overview/index.html

The following are steps to install the Java 9 JDK on the Windows OS:

1. Install the Java 9 JDK by right-clicking the installer’s executable (jdk-9-windows-x64.exe) to run as an administrator. Typically, other operating systems will pop up a similar warning dialog box to alert you of the risks of installing or running binary files. Click the Run button to proceed.

2. Begin the installation process by clicking on the Next button , as shown in Figure 1-1.

   

   Figure 1-1. Java SE Development Kit 9 installation process

3. Next, you’ll be presented with the Custom Setup window allowing you to select optional features shown in Figure 1-2. Here, you’ll just accept the default selections and click the Next button to continue.

   

   Figure 1-2. Java SE Development Kit 9 optional features

4. Afterward, the installation process will display a progress bar , as shown in Figure 1-3.

   

   Figure 1-3. Java SE Development Kit 9 installation in progress

5. Next, a popup dialog window will ask if you want to change the installation directory of the Java runtime. Just click the Next button and accept the default directory, as shown in Figure 1-4.

   

   Figure 1-4. The Java 9 runtime destination directory

6. To complete the installation of the Java 9 SE Development Kit, click the Close button to exit, as shown in Figure 1-5.

   

   Figure 1-5. The last part of the installation prompting that the Java SE Development Kit 9 was successfully installed

Installing the JDK on MacOS X

The following steps use the Java 9 JDK 64-bit version for the MacOS X (El Capitan) operating system. It assumes you’ve already downloaded the JDK and it’s called something similar to the following:

jdk-9-ea-bin-b88-macosx-x86_64-21_oct_2015.dmg

Use the following steps to install the Java 9 JDK on the MacOS X operating system:

1. After launching the dmg file, you’ll be presented the following dialog box as shown in Figure 1-6. Next, double-click on the icon to begin the install process.

   

   Figure 1-6. The Java 9 JDK installer on the MacOS X operating system

2. Next, to begin the install process shown in Figure 1-7, click on Continue. For the rest of the installation process, accept the defaults.

   

   Figure 1-7. The Java 9 JDK installer introduction for the MacOS X operating system

3. After clicking on the Continue button, the dialog will mention the amount of disk space the JDK will take up on your computer, as shown in Figure 1-8. Click on the Install button to proceed .

   

   Figure 1-8. The prompt showing how much space the JDK will use

4. For security purposes, your MacOS X will prompt you with a password to allow the installer to continue, as shown in Figure 1-9. This assumes you have admin privileges to install software. After entering your password, click the Install Software button to kick off the process.

   

   Figure 1-9. The permission window prompting for the username and password that will allow the JDK software to be install on the local machine

5. The installation process will take a few seconds , as shown in Figure 1-10.

   

   Figure 1-10. The installation of the JDK in progress

6. Lastly, you will click on the Close button, as shown in Figure 1-11. This completes the JDK installation on the MacOS operating system.

   

   Figure 1-11. The installation of the JDK is complete

After finishing the installation of the JDK, you’ll learn later in this chapter how to set up your environment variables. Next are instructions for installing JDK 9 on Linux-based operating systems.

Installing the JDK on Linux

To begin, you should determine if your Linux system is a 32-bit or 64-bit architecture by typing in the following in a terminal:

$ uname -m

The output on a 64 bit Linux machine is as follows:

x86_64

The output on a 32 bit Linux machine is as follows:

i686

Assuming you’ve downloaded the Java JDK at the following:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

For users in the Linux world, you will need to download a file named something like:

• jdk-9-bin-b88-linux-i586-21_oct_2015.tar.gz

• jdk-9-bin-b88-linux-i586-21_oct_2015.rpm.

Locate the downloaded file (*.gz or *.rpm) and then go to your terminal window to begin the installation process. The instructions for the installation process are in the next section.

$ mv ∼/Downloads/jdk-9-linux-x64.tar.gz /tmp
$ cd /tmp
$ tar zxvf /tmp/jdk-9-linux-x64.tar.gz
$ sudo mkdir /opt/jdk/
$ sudo mv jdk-9 /opt/jdk

$ sudo rpm -ivh jdk-9-linux-x64.rpm

$ sudo update
$ sudo alternatives --install /usr/bin/java java /opt/jdk/jdk-9/bin/java 100

$ sudo alternatives --config java

There are 3 programs which provide 'java'.

  Selection    Command
-----------------------------------------------
  * 1          /opt/jdk/jdk1.8.0_51/bin/java
  + 2          /opt/jdk/jdk1.8.0_66/bin/java
    3          /opt/jdk/jdk-9/bin/java

Enter to keep the current selection[+], or type selection number: 3

$ java -version

java version "1.9.0-ea"
Java(TM) SE Runtime Environment (build 1.9.0-ea-b90)
Java HotSpot(TM) 64-Bit Server VM (build 1.9.0-ea-b90, mixed mode)

$ sudo alternatives --install /usr/bin/javac javac /opt/jdk/jdk-9/bin/javac 100
$ sudo alternatives --config javac

There are 3 programs which provide 'javac'.

  Selection    Command
-----------------------------------------------
  * 1          /opt/jdk/jdk1.8.0_51/bin/javac
  + 2          /opt/jdk/jdk1.8.0_66/bin/javac
    3          /opt/jdk/jdk-9/bin/javac

$ javac -version

javac 1.9.0-ea

$ sudo apt-get update
$ sudo apt-get install oracle-java9-installer

$ mv ∼/Downloads/jdk-9-linux-x64.tar.gz /tmp
$ cd /tmp
$ tar zxvf jdk-9-linux-x64.tar.gz
$ sudo mv jdk-9 /usr/lib/jvm/

$ sudo update
$ sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-9-linux-x64/bin/java 100

$ sudo update-alternatives --config java

There are 2 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                      Priority   Status
-----------------------------------------------------------------------------
* 0            /usr/lib/jvm/java-8-openjdk/jre/bin/java  1061       auto mode
  1            /usr/lib/jvm/java-9-oracle/bin/java       100        manual mode

Press enter to keep the current choice[*], or type selection number: 1

$ sudo update-alternatives --display java

  Selection    Path                                       Priority   Status
-----------------------------------------------------------------------------
  0            /usr/lib/jvm/java-8-openjdk/jre/bin/java   1061       auto mode
* 1            /usr/lib/jvm/java-9-oracle/bin/java        100        manual mode

$ sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk-9-linux-x64/bin/javac 100
$ sudo update-alternatives --config javac

There are 2 choices for the alternative javac (providing /usr/bin/javac).

  Selection    Path                                    Priority   Status
-----------------------------------------------------------------------------
* 0            /usr/lib/jvm/java-8-openjdk/bin/javac   1061       auto mode
  1            /usr/lib/jvm/java-9-oracle/bin/javac    100        manual mode

Press enter to keep the current choice[*], or type selection number: 1

$ sudo update-alternatives --config javac

There are 2 choices for the alternative javac (providing /usr/bin/javac).

  Selection    Path                                    Priority   Status
-----------------------------------------------------------------------------
  0            /usr/lib/jvm/java-8-openjdk/bin/javac   1061       auto mode
* 1            /usr/lib/jvm/java-9-oracle/bin/javac    100        manual mode                                                                                                                                                                

Setup Windows Environment Variables

In the Windows environment you can use the keyboard shortcut Windows logo key+Pause/Break key, and then click the Advanced system settings (link on the left side) to display the Systems Properties window, as shown in Figure 1-12.

Figure 1-12. The System Properties window

Next, click the Environment Variables button . At this point you can add, edit, and delete environment variables. You will add or edit the JAVA_HOME environment variable by using the installed home directory as the value. The Environment Variables window on the Windows operating system is shown in Figure 1-13.

Figure 1-13. Windows Environment Variables window

To add the JAVA_HOME environment variable, click on the New button shown in Figure 1-13.

After you click the New button, the window in Figure 1-14 appears and allows you to enter the environment variable name and value . When you’re done, click on the OK button.

Figure 1-14. The Add/Edit window to enter the JAVA_HOME environment variable

After, you’ve clicked on OK to add JAVA_HOME, you will need update the Path environment variable, as shown in Figure 1-15. Select the Path environment variable in the System Variables area. Next, click on the Edit button.

Figure 1-15. Editing the Path environment variable

In Windows 10, you need to edit the Path environment variable by adding an new entry, as shown in Figure 1-16. Here you will add an entry such as %JAVA_HOME%in. To add the entry, click on the New button. If the entry already exists , click on the Edit button. This allows the system to see all binary executables in the bin directory of the JAVA_HOME. In other words, when you are on the terminal or command-line prompt, the system will recognize files such as javac.exe for the Java compiler.

Figure 1-16. Adding %JAVA_HOME%in to the Path environment variable

In Figure 1-16, the %JAVA_HOME%in entry was at the bottom of the list, but I moved it to the top by clicking on the Move Up button .

Setting Up MacOS X/Linux Environment Variables

To make the environment variables permanent on MacOS X or Linux , you can use common text editors such as nano or vim. But before you go editing your user shell profile files, you will want to make a backup copy just in case you make a mistake. Because many Unix and Linux systems have different shells, I’ve detailed the typical files to copy and edit.

On a Mac, type the following:

$ cp ∼/.bash_profile ∼/.bash_profile.orig

On a Linux OS, you’ll type the following to determine the kind of shell you have, then you’ll know which file to copy and edit. Different shells use different files to export environment variables when creating a console session .

$  echo $0
-bash

If the output displays -bash, you’ll want to back up and edit the .bashrc file from your home directory. If the output displays -csh, you’ll want to back up and edit the .cshrc from your home directory. Next, you copy the .bashrc file as a backup before editing it.

$ cp ∼/.bashrc ∼/.bashrc.orig

If you’re on a Linux OS using the C shell, type the following:

$ cp ∼/.cshrc ∼/.cshrc.orig

Now, you’ll want to edit the file that you just backed up by using nano or vi text editor. To load a file, you type the following:

$ nano ∼/.bash_profile

Or

$ vi ∼/.bash_profile

Notice that I used the ∼/.bash_profile file located in the home directory on the MacOS X operating system. I trust you will replace the file with the particular file depending on your Linux OS and shell. After loading the file from the previous command you will want to perform edits, saves, and exits from those editors. Tables 1-1 and 1-2 are quick run-downs of the common commands for nano and vim, respectively.

• To set your JAVA_HOME for the MacOS X platform, you need to launch a terminal window to edit your home directory’s .bash_profile file (for example , nano ∼/.bash_profile) by adding the export commands at the bottom of the file:

  # Mac OS X /bin/bash
  export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-9.jdk/Contents/Home
  export PATH=$PATH:$JAVA_HOME/bin

• On Linux and other Unix operating systems that use Bash shell environments, launch a terminal window and edit either the ∼/.bashrc or ∼/.profile file to contain the export commands. Add the export commands.

  # Linux bash, bourne shell environments /bin/bash
  export JAVA_HOME=/usr/java/jdk-9
  export PATH=$PATH:$JAVA_HOME/bin

• On Linux and other Unix operating systems that use C shell (csh) environments, launch a terminal window and edit either the ∼/.cshrc or ∼/.login file to contain the setenv commands. Add the export commands.

  #csh environments
  setenv JAVA_HOME /usr/java/jdk-9
  setenv PATH ${JAVA_HOME}/bin:${PATH}

Once you’ve set up your path and JAVA_HOME environment variables , you will want to verify them by launching a terminal window and executing the following two commands from the command prompt:

$ java -version
$ javac -version

The output in each case should display a message indicating the Java 9 version of the language and runtime. Here is the display output of the version.

Java -version

java version "1.9.0-ea"
Java(TM) SE Runtime Environment (build 1.9.0-ea-b90)
Java HotSpot(TM) 64-Bit Server VM (build 1.9.0-ea-b90, mixed mode)

javac -version

javac 1.9.0

Using the NetBeans IDE

To quickly get started with creating, coding, compiling, and running a simple JavaFX HelloWorld application using the NetBeans IDE, follow the steps outlined in this section. You’ll want to go deeper in the next section to get an understanding of what the IDE is doing behind the scenes on your behalf. For now, though, let’s just get some code written and running.

1. Launch NetBeans IDE.

2. On the File menu, select File ➤ New Project.

3. Under Choose Project and Categories , select the JavaFX folder.

4. Under Projects, select Java FX Application, and click Next.

5. Specify HelloWorld for your project name.

6. Change or accept the defaults for the Project Location and Project Folder fields . Figure 1-24 shows the New JavaFX Application wizard used to create a simple HelloWorld application.

   

   Figure 1-24. New JavaFX Application wizard

7. On this screen (Figure 1-24), click the Manage Platforms button to make sure the Platform Name field contains JDK 1.9 or greater as the default. Click Finish to auto-create the JavaFX HelloWorld application.

8. In a few seconds, NetBeans will generate all the necessary files for the HelloWorld project. After NetBeans finishes, the project will show up on the left Projects tab. Figure 1-25 shows a newly created HelloWorld project .

   

   Figure 1-25. A newly created HelloWorld project

9. In the NetBeans IDE on the Projects tab (left), select the newly created project. Open the Project Properties dialog box from the File menu option Project Properties. Here you will verify that the Source/Binary format setting is using JDK 9, as shown in Figure 1-26. Click Sources under Categories.

   

   Figure 1-26. Project properties

10. To run and test your JavaFX HelloWorld application, ensure the project folder is selected (the left Projects tab), then click on the green Run button or press the F6 key to execute the HelloWorld project. Figure 1-27 shows the Run Project option used to launch the JavaFX application.

    

    Figure 1-27. Running the HelloWorld project

11. After you choose the Run option, the output should look like Figure 1-28.

    

    Figure 1-28. JavaFX HelloWorld launched from the NetBeans IDE

You shouldn’t encounter any difficulty when following Steps 1 through 8. However, steps 9 ensures that your project’s source/binary format is using JDK 9. Because of the new additions to the Java language in Java 9, such as modules, some of the source code in this book will rely on the new syntax and therefore will not be backward-compatible with prior versions of Java 9. Typically, developers have prior versions of the Java development kit such as JDK 8. NetBeans allows you to switch between different JDKs when projects require older versions. An important thing to note is that in early releases of JavaFX 2.0, the software was packaged separately from the Java SDK, which caused some software versioning confusion. Thank goodness it is now just one download (JDK 9)! If you are still using Java 7 SDK, the latest download will also contain JavaFX in one bundle since JavaFX 2.1.

Using an Editor and the Terminal (the Command-Line Prompt )

The second way of developing JavaFX 9 applications is to use a common text editor and the command-line prompt (terminal). By learning how to compile and execute applications on the command-line prompt, you will learn about the classpath and where the executable files reside. Being exposed to this will sharpen your skills when you are in environments where fancy IDEs and/or editors aren’t easily available.

Working from the command line, you will basically use a text editor such as nano, vi, Emacs, or Notepad to code your JavaFX HelloWorld source. The example shown in Listing 1-1 is of a HelloWorld Java application.

Listing 1-1. A JavaFX HelloWorld Application from HelloWorld.java

package org.acme.helloworld;

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.stage.Stage;

/**
 * A JavaFX Hello World Application
 */
public class HelloWorld extends Application {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Application.launch(args);
    }

    @Override
    public void start(Stage stage) {
        stage.setTitle("Hello World");
        Group root = new Group();
        Scene scene = new Scene(root, 300, 250);
        Button btn = new Button();
        btn.setLayoutX(100);
        btn.setLayoutY(80);
        btn.setText("Hello World");
        btn.setOnAction(new EventHandler<ActionEvent>() {

            public void handle(ActionEvent event) {
                System.out.println("Hello World");
            }
        });
        root.getChildren().add(btn);
        stage.setScene(scene);
        stage.show();
    }
}

Once the Java file is created you will use the command-line prompt or terminal window to compile and run your JavaFX application. The following are steps to create a JavaFX HelloWorld application to be compiled and run on the command-line prompt (terminal).

1. In your user home directory, make a projects directory and underneath it you will create a helloworld directory.

   On a MacOS or Linux operating system, use the following command to make a projects directory:

   $ mkdir -p ∼/projects/helloworld/src
   $ mkdir ∼/projects/helloworld/classes
   $ cd ∼/projects/helloworld/
   $ nano src/HelloWorld.java

   On a Windows operating system, use the following command to change directories:

   C:Usersmyusername>mkdir projects
   C:Usersmyusername>mkdir projectshelloworld
   C:Usersmyusername>mkdir projectshelloworldsrc
   C:Usersmyusername>mkdir projectshelloworldclasses
   C:Usersmyusername>cd projectshelloworld
   C:Usersmyusernameprojectshelloworld>notepad srcHelloWorld.java

2. Copy and paste the code from Listing 1-1 into a text editor and save the file as HelloWorld.java. The file should reside inside the src directory.

   Note When entering the code for the HelloWorld.java file from Listing 1-1, be sure to include the package org.acme.helloworld; statement at the top. By doing so, the package namespace directories are created when the code is compiled. For example, the compiled HelloWorld.class file will reside in the classes/org/acme/helloworld directory.

3. Compile the source code file called HelloWorld.java using the Java compiler javac with the -d switch and the classes directory. The classes directory is where the compiled code goes. Also, you need to specify the source code files to compile, which is src/*.java. The commands you need to enter depend on your operating system.

   On a MacOS X or Linux operating system, type the following on the command-line prompt:

   $ javac -d classes src/*.java

   On a Windows command line, type the following:

   C:Usersmyusernameprojectshelloworld> javac -d classes src*.java

   Notice the -d classes before the filename. The -d option (destination directory) lets the Java compiler know where to put the compiled class files based on their package namespace. In this scenario, the HelloWorld package statement (namespace) is org.acme.helloworld, which will create subdirectories under the classes directory, assuming you are in the ∼/projects/helloworld project directory.

   When you’re finished compiling, your directory structure should resemble Figure 1-29.

   

   Figure 1-29. The compiled HelloWorld example creates directories based on the package namespace under the classes directory. You will notice the subdirectories are created as org/acme/helloworld under the classes directory you created earlier.

4. Run and test your JavaFX HelloWorld application . Assuming you are in the ∼/projects/helloworld directory, type the following command to run your JavaFX HelloWorld application from the command-line prompt:

   $ java -cp classes org.acme.helloworld.HelloWorld

On Windows OS:

C:Usersmyusernameprojectshelloworld> java -cp classes org.acme.helloworld.HelloWorld

By using the -cp, classes will let Java know where the classpath directory is located. Figure 1-30 shows the output of a simple JavaFX HelloWorld application launched from the command-line prompt .

Figure 1-30. JavaFX HelloWorld launched from the MacOS X command-line prompt

Using Gradle on the Command-Line Prompt

A third way of developing JavaFX applications is using the Gradle Build tool. Here you will be also using a common text editor like before, but instead of manual steps in creating and compiling code, you will be relying on the Gradle Build tool. If you have not set up Gradle, refer to the early part of this chapter in the section entitled “Installing Gradle.” Follow these steps to create a Gradle-based project .

1. Create another project and directory named helloworld_gradle. Assuming you are in the ∼/projects directory, you will create a Gradle-based project.

   On a Unix-like OS, enter the following:

   $ mkdir -p projectshelloworld_gradle

   On Windows, enter the following:

   C:Usersmyusername>mkdir projectshelloworld_gradle

2. Change your directory to the helloworld_gradle.

   On a Unix-like OS, enter the following:

   $ cd helloworld_gradle

   On Windows, enter the following:

   C:Usersmyusername>cd projectshelloworld_gradle

3. Build a Java skeleton project having the conventional directory structure (Maven and Gradle convention). You will notice directories created that will look like src/main/java and src/test/java. Since this creates the project files and directories initially, it should only be done once. The following command creates a Java library project:

   $ gradle init --type java-library

   The following is the output when executing the Gradle init task:

   :wrapper
   :init
   
   BUILD SUCCESSFUL
   
   Total time: 1.897 secs

4. Since you are creating a JavaFX application and not a Java library, you will remove the Library.java and LibraryTest.java files under the src/main/java and src/test/java directories , respectively. These files are just stubbed out to get you started if you decide to create a Java library. In this scenario, you are creating a JavaFX application.

5. Next, you’ll create a directory called org/acme/helloworld under the src/main/java directory and copy the HelloWorld.java file from Listing 1-1 into the src/main/java/org/acme/helloworld directory. This will look like Figure 1-31.

   

   Figure 1-31. Gradle Java application project structure. Notice the standard convention of source code directory structure laid out as src/main/java and src/test/java. Build tools such as Maven and Gradle follow this convention.

6. Since you are creating a JavaFX application, you will need to edit the build.gradle file by adding a plug-in that will build the Java project as a launchable application. You’ll also add one more entry to let Gradle know which class the main application should be run as. Using your text editor, add the following entries to the build.gradle file:

   apply plugin: 'application'
   
   mainClassName = "org.acme.helloworld.HelloWorld"

7. After you’ve saved and exited the file, you’ll want to build the project using the gradle assemble command. This will create an executable jar file that can be run. Type the following to compile and build a HelloWorld jar executable.

   $ gradle assemble

   The following is the output after executing the Gradle assemble task.

   :compileJava
   Download https://jcenter.bintray.com/org/slf4j/slf4j-api/1.7.12/slf4j-api-1.7.12.pom
   Download https://jcenter.bintray.com/org/slf4j/slf4j-parent/1.7.12/slf4j-parent-1.7.12.pom
   Download https://jcenter.bintray.com/org/slf4j/slf4j-api/1.7.12/slf4j-api-1.7.12.jar
   :processResources UP-TO-DATE
   :classes
   :jar
   :assemble
   
   BUILD SUCCESSFUL
   
   Total time: 4.458 secs

8. Now run the HelloWorld application by using the following command (run task).

   $ gradle run

9. The Gradle run task was added when you added the plug-in entry apply plugin: 'application'. Gradle plug-ins provide convenient ways to build different kinds of Java projects and artifacts. You should see the Java HelloWorld application launch just like in Figure 1-30.

There are many more powerful things you can do with Gradle that are beyond the scope of this book; however, I will list some common commands you might be interested in using.

• gradle tasks: Lists all the available tasks

• gradle clean: Removes directories and files from the build directory

• gradle eclipseProject: Creates project files for the Eclipse IDE. This task will be available when you add the following statement to the build.gradle file:

  apply plugin: 'eclipse'

• gradle intellijProject: Creates project files for the IntelliJ IDE. This task will be available when you add the following statement to the build.gradle file:

  apply plugin: 'idea'

• gradle -help: Shows the available options and descriptions of commands

JavaFX Scene Graph

You’ll notice that some classes and objects are oddly named, such as Stage and Scene. There isn’t a coincidence—the designers of the API have modeled things after the idea of a theater or a play in which actors perform in front of an audience. In this analogy, a play consists of one-to-many scenes in which actors perform. And, of course, all scenes are performed on a stage one at a time. In JavaFX, the Stage is equivalent to an application window similar to Java Swing API JFrame or JDialog on the desktop. Depending on the device, such as a Raspberry Pi (Raspbian), there may be only one stage. You can think of a Scene object as a content pane, similar to Java Swing’s JPanel, capable of holding zero-to-many Node objects (children).

Proceeding with the example, in the start() method, you see that for a JavaFX desktop window (stage) you can set the title bar using the setTitle() method. Next, you create a root node (Group), which is added to the Scene object as the top-level surface for the application window. The following code snippet shows you how to set the title and create the scene:

stage.setTitle("Hello World");
Group root = new Group();
Scene scene = new Scene(root, 300, 250);

JavaFX Node

A JavaFX node is a fundamental base class for all scene graph nodes to be rendered. The following graphics capabilities can be applied to nodes: scaling, transforms, translations, and effects.

Some of the most commonly used nodes are UI controls and Shape objects. Similar to a tree data structure, a scene graph will contain children nodes by using a container class such as the Group or Pane class. You’ll learn more about the Group class later when you look at the ObservableList class, but for now you can think of them as Java List or Collection classes that are capable of holding child node objects. In the following code, a button (Button) node is created to be positioned on the scene and set with an event handler (EventHandler<ActionEvent>), which responds when the user presses the button. The handler code will output the text "Hello World" on the console. For now the code shown here uses an anonymous inner class; however you will learn later in Chapter 3 to use lambda expressions introduced in Java 8.

Button btn = new Button();
btn.setLayoutX(100);
btn.setLayoutY(80);
btn.setText("Hello World");
btn.setOnAction(new EventHandler<ActionEvent>() {
    public void handle(ActionEvent event) {
       System.out.println("Hello World");
    }
});
root.getChildren().add(btn);

Once the child nodes have been added to the root Group via the getChildren().add() method, you set the stage’s scene and call the show() method on the Stage object to display a JavaFX application window. By default, the window will allow users to minimize, maximize, and close (exit) the application. The following code sets the scene and displays the JavaFX application window (the Stage):

stage.setScene(scene);
stage.show();