Sample: SimpleCalculator

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class SimpleCalculator extends JFrame {

  // Text fields for Number 1, Number 2, and Result

  private JTextField jtfNum1, jtfNum2, jtfResult;

  // Buttons "Add", "Subtract", "Multiply" and "Divide"

  private JButton jbtAdd, jbtSub, jbtMul, jbtDiv;

  // Main Method

  public static void main(String[] args) {

    SimpleCalculator frame = new SimpleCalculator();

    frame.pack();

    frame.setTitle("SimpleCalculator");

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    frame.setLocationRelativeTo(null); // Center the frame

    frame.setVisible(true);

  }

  // Default Constructor

  public SimpleCalculator() {

    // Panel p1 to hold text fields and labels

    JPanel p1 = new JPanel();

    p1.setLayout(new FlowLayout());

    p1.add(new JLabel("Number 1"));

    p1.add(jtfNum1 = new JTextField(3));

    p1.add(new JLabel("Number 2"));

    p1.add(jtfNum2 = new JTextField(3));

    p1.add(new JLabel("Result"));

    p1.add(jtfResult = new JTextField(8));

    jtfResult.setEditable(false);

    jtfResult.setHorizontalAlignment(SwingConstants.RIGHT);

    // Panel p2 to hold buttons

    JPanel p2 = new JPanel();

    p2.setLayout(new FlowLayout());

    p2.add(jbtAdd = new JButton("Add"));

    p2.add(jbtSub = new JButton("Subtract"));

    p2.add(jbtMul = new JButton("Multiply"));

    p2.add(jbtDiv = new JButton("Divide"));

    // Set mnemonic keys

    jbtAdd.setMnemonic('A');

    jbtSub.setMnemonic('S');

    jbtMul.setMnemonic('M');

    jbtDiv.setMnemonic('D');

    // Add panels to the frame

    setLayout(new BorderLayout());

    add(p1, BorderLayout.CENTER);

    add(p2, BorderLayout.SOUTH);

    // Register listeners

    jbtAdd.addActionListener(new Listener());

    jbtSub.addActionListener(new Listener());

    jbtMul.addActionListener(new Listener());

    jbtDiv.addActionListener(new Listener());

  }

  class Listener implements ActionListener {

    // Handle ActionEvent from buttons and menu items

    public void actionPerformed(ActionEvent e) {

      String actionCommand = e.getActionCommand();

      if ("Add".equals(actionCommand))

          calculate('+');

      else if ("Subtract".equals(actionCommand))

        calculate('-');

      else if ("Multiply".equals(actionCommand))

        calculate('*');

      else if ("Divide".equals(actionCommand))

        calculate('/');

    }

  }

  // Calculate and show the result in jtfResult

  private void calculate(char operator) {

    // Obtain Number 1 and Number 2

    double num1 = new Double(jtfNum1.getText().trim()).doubleValue();

    double num2 = new Double(jtfNum2.getText().trim()).doubleValue();

    double result = 0;

    // Perform selected operation

    switch (operator) {

      case '+': result = num1 + num2;

                break;

      case '-': result = num1 - num2;

                break;

      case '*': result = num1 * num2;

                break;

      case '/': result = num1 / num2;

    }

    // Set result in jtfResult

    jtfResult.setText(String.valueOf(result));

  }

}

Sample: LoanCalculator

LoanCalculator.java, Loan.java

  /*

   Introduction to OOP with Java (5th Ed), McGraw-Hill

 

   Wu/Otani

 

   Chapter 4 Sample Development: Loan Calculation (Step 5)

 

   File: Step5/LoanCalculator.java

 

   This class controls the input, computation, and output of loan

 */

 import java.text.DecimalFormat;

import java.util.*;

 class LoanCalculator {

// ----------------------------------

//     Data Members

// ----------------------------------

      // This object does the actual loan computation

     private Loan loan;

    

     private Scanner scanner;

// ----------------------------------

 //

//   Main Method

 //

// ----------------------------------

     public static void main(String[] arg) {

        

         LoanCalculator calculator = new LoanCalculator();

         calculator.start();

     }

// ----------------------------------

//     Constructors

// ----------------------------------

     public LoanCalculator() {

        

         scanner = new Scanner(System.in);

        

     }

// -------------------------------------------------

//       Public Methods:

 //

//           void start (        )

 //

// ------------------------------------------------

     //Top-level method that calls other private methods

     public void start() {

         describeProgram();   //tell what the program does

         getInput();          //get three input values

         displayOutput();     //display the results

     }

// -------------------------------------------------

//       Private Methods:

 //

//       void    describeProgram   (        )

//       void    displayOutput     (        )

//       void    getInputs         (        )

 //

// ------------------------------------------------

     // Provides a brief explanation of the program to the user.

     private void describeProgram() {

         System.out.println("This program computes the monthly and total");

         System.out.println("payments for a given loan amount, annual ");

         System.out.println("interest rate, and loan period (# of years).");

         System.out.println("\n");

     }

     //Displays the input values and monthly and total payments.

     private void displayOutput() {

        

         DecimalFormat df = new DecimalFormat("0.00");

        

         System.out.println("Loan Amount: $" + loan.getAmount());

         System.out.println("Annual Interest Rate:"

                             + loan.getRate() + "%");

         System.out.println("Loan Period (years): " + loan.getPeriod());

         System.out.println("Monthly payment is $ " +

                                        df.format(loan.getMonthlyPayment()));

         System.out.println("  TOTAL payment is $ " +

                                        df.format(loan.getTotalPayment()));

     }

     // Gets three input values--loan amount, interest rate, and

     // loan period

     private void getInput() {

         double  loanAmount, annualInterestRate;

         int     loanPeriod;

         System.out.print("Loan Amount (Dollars+Cents):");

         loanAmount  = scanner.nextDouble();

         System.out.print("Annual Interest Rate (e.g., 9.5):");

         annualInterestRate = scanner.nextDouble();

         System.out.print("Loan Period - # of years:");

         loanPeriod  = scanner.nextInt();

         //create a new loan with the input values

         loan = new Loan(loanAmount, annualInterestRate,loanPeriod);

     }

 }

//---------------------

// Loan Class (Step 5)

/*

   Introduction to OOP with Java (5th Ed), McGraw-Hill

 

   Wu/Otani

 

   Chapter 4 Sample Development: Loan Calculation (Step 5)

 

   File: Step5/Loan.java

 

   NO CHANGES from STEP 4 CODE

  

   This class handles the loan computation.

*/

class Loan {

//----------------------------------

//    Data Members

//----------------------------------

    // Constant for the number of months in a year

    private final int MONTHS_IN_YEAR = 12;

    // The amount of the loan

    private double    loanAmount;

    //The monthly interest rate

    private double    monthlyInterestRate;

    // The number of monthly payments

    private int       numberOfPayments;

//----------------------------------

//    Constructor

//----------------------------------

    //Creates a new Loan object with passed values.

    public Loan(double amount, double rate, int period) {

        setAmount(amount);

        setRate  (rate  );

        setPeriod(period);

    }

//-------------------------------------------------

//      Public Methods:

//

//          double  getAmount   (           )

//          double  getPeriod   (           )

//          int     getRate     (           )

//

//          double  getMontlyPayment(       )

//          double  getTotalPayment (       )

//

//          void    setAmount   ( double    )

//          void    setPeriod   ( int       )

//          void    setRate     ( double    )

//

//------------------------------------------------

    //Returns the loan amount.

    public double getAmount( ) {

        return loanAmount;

    }

    //Returns the loan period in the number of years.

    public int getPeriod( ) {

        return numberOfPayments / MONTHS_IN_YEAR;

    }

    //Returns the annual interest rate.

    public double getRate( ) {

        return monthlyInterestRate * 100.0 * MONTHS_IN_YEAR;

    }

   

    //Returns the monthly payment

    public double getMonthlyPayment( ) {

        double monthlyPayment;

        monthlyPayment = (loanAmount * monthlyInterestRate)

                           /

                         (1 - Math.pow(1/(1 + monthlyInterestRate),

                                          numberOfPayments ) );

        return monthlyPayment;

    }

   

    //Returns the total payment

    public double getTotalPayment( ) {

        double totalPayment;

        totalPayment = getMonthlyPayment( ) * numberOfPayments;

        return totalPayment;

    }

    //Sets the loan amount of this loan.

    public void setAmount(double amount) {

        loanAmount = amount;

    }

    //Sets the interest rate of this loan.

    public void setRate(double annualRate) {

        monthlyInterestRate = annualRate / 100.0 / MONTHS_IN_YEAR;

    }

    //Sets the loan period of this loan.

    public void setPeriod(int periodInYears) {

        numberOfPayments = periodInYears * MONTHS_IN_YEAR;

    }

}

Sample: LibraryCard

LibraryCard.java,  Librarian.java

/*

    Introduction to OOP with Java (5th Ed), McGraw-Hill

    Wu/Otani

    File: LibraryCard.java

*/

class LibraryCard {

    // Data Members  

   

    //student owner of this card

    private Student owner;

   

    //number of books borrowed

    private int borrowCnt;

   

    //numOfBooks are checked out

    public void checkOut(int numOfBooks) {

        borrowCnt = borrowCnt + numOfBooks;

    }

   

    //Returns the name of the owner of this card

    public String getOwnerName( ) {

        return owner.getName( );

    }

   

    //Returns the number of books borrowed

    public int getNumberOfBooks( ) {

        return borrowCnt;

    }

   

    //Sets the owner of this card to student

    public void setOwner(Student student) {

        owner = student;

    }

   

   

    //Returns the string representation of this card

    public String toString( ) {

        return  "Owner Name:     " + owner.getName( ) + "\n" +

                "      Email:    " + owner.getEmail( ) + "\n" +

                "Books Borrowed: " + borrowCnt;

    }

      

 }

//-----------------

/*

    Introduction to OOP with Java (5th Ed), McGraw-Hill

    Wu/Otani

    File: Librarian.java

*/

class Librarian {

  

    public static void main( String[] args ) {

   

        Student    student;

        LibraryCard card1, card2;

       

        student = new Student( );

        student.setName("Jon Java");

        student.setEmail("jj@javauniv.edu");

       

        card1 = new LibraryCard( );

        card1.setOwner(student);

        card1.checkOut(3);

       

        card2 = new LibraryCard( );

        card2.setOwner(student); //the same student is the owner

                                 //of the second card, too

       

        System.out.println("Card1 Info:");

        System.out.println(card1.toString() + "\n");

       

        System.out.println("Card2 Info:");

        System.out.println(card2.toString() + "\n");

      

    }

}

Sample: investment

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.border.*;

public class Investment extends JFrame {

  private JTextField jtfInvestmentAmount;

  private JTextField jtfYears;

  private JTextField jtfInterestRate;

  private JTextField jtfFutureValue;

  private JButton jbtCalculate;

  public static void main(String[] args) {

    JFrame frame = new  Investment();

    frame.pack();

    frame.setTitle("Investment");

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    frame.setLocationRelativeTo(null); // Center the frame

    frame.setVisible(true);

  }

  public  Investment() {

    // Create a new panel with GridLayout to hold labels and text boxes

    JPanel p = new JPanel();

    p.setLayout(new GridLayout(4, 2, 5, 0));

    p.setBorder(new EmptyBorder(5, 5, 5, 5));

    p.add(new JLabel("Investment Amount"));

    p.add(jtfInvestmentAmount = new JTextField(8));

    p.add(new JLabel("Years"));

    p.add(jtfYears = new JTextField(8));

    p.add(new JLabel("Annual Interest Rate"));

    p.add(jtfInterestRate = new JTextField(8));

    p.add(new JLabel("Future value"));

    p.add(jtfFutureValue = new JTextField(8));

    jtfFutureValue.setEditable(false);

    // Add the panel and a button to the frame

    setLayout(new BorderLayout());

    add(p, BorderLayout.CENTER);

    // Add a button to a panel

    JPanel p1 = new JPanel(new FlowLayout(FlowLayout.RIGHT));

    p1.add(jbtCalculate = new JButton("Calculate"));

    add(p1, BorderLayout.SOUTH);

    jbtCalculate.setMnemonic('C');

    jtfInvestmentAmount.setHorizontalAlignment(JTextField.RIGHT);

    jtfYears.setHorizontalAlignment(JTextField.RIGHT);

    jtfInterestRate.setHorizontalAlignment(JTextField.RIGHT);

    jtfFutureValue.setHorizontalAlignment(JTextField.RIGHT);

    // Register listener

    jbtCalculate.addActionListener(new ActionListener() {

      // Handle ActionEvent

      public void actionPerformed(ActionEvent e) {

        calculate();

      }

    });

  }

  // Calculate future value

  public void calculate() {

    double investmentAmount =

      Double.valueOf(jtfInvestmentAmount.getText().trim()).

      doubleValue();

    int years =

      Integer.valueOf(jtfYears.getText().trim()).intValue();

    double interestRate = Double.valueOf(jtfInterestRate.getText().

      trim()).doubleValue();

    double futureValue = investmentAmount * Math.pow((1 +

      interestRate / (12 * 100)), 12 * years);

//    NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US);

//    jtfFutureValue.setText(nf.format(futureValue));

    jtfFutureValue.setText((int)(futureValue * 100) / 100.0 + "");

  }

}

Example 17

Chapter 17

//-----------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class TestFileStream {
  public static void main(String[] args) throws IOException {
    try (
      // Create an output stream to the file
      FileOutputStream output = new FileOutputStream("temp.dat");
    ) {
      // Output values to the file
      for (int i = 1; i <= 10; i++)
        output.write(i);
    }

    try (
      // Create an input stream for the file
      FileInputStream input = new FileInputStream("temp.dat");
    ) {
      // Read values from the file
      int value;
      while ((value = input.read()) != -1)
        System.out.print(value + " ");
    }
  }
}

//------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class TestDataStream {
  public static void main(String[] args) throws IOException {
    try ( // Create an output stream for file temp.dat
      DataOutputStream output =
        new DataOutputStream(new FileOutputStream("temp.dat"));
    ) {
      // Write student test scores to the file
      output.writeUTF("John");
      output.writeDouble(85.5);
      output.writeUTF("Jim");
      output.writeDouble(185.5);
      output.writeUTF("George");
      output.writeDouble(105.25);
    }
   
    try ( // Create an input stream for file temp.dat
      DataInputStream input =
        new DataInputStream(new FileInputStream("temp.dat"));
    ) {
      // Read student test scores from the file
      System.out.println(input.readUTF() + " " + input.readDouble());
      System.out.println(input.readUTF() + " " + input.readDouble());
      System.out.println(input.readUTF() + " " + input.readDouble());
    }
  }
}

//-------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class DetectEndOfFile {
  public static void main(String[] args) {
    try {
      try (DataOutputStream output =
        new DataOutputStream(new FileOutputStream("test.dat"))) {
        output.writeDouble(4.5);
        output.writeDouble(43.25);
        output.writeDouble(3.2);
      }
     
      try (DataInputStream input =
        new DataInputStream(new FileInputStream("test.dat"))) {
        while (true)
          System.out.println(input.readDouble());
      }
    }
    catch (EOFException ex) {
      System.out.println("All data were read");
    }
    catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

//---------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class Copy {
  /** Main method
     @param args[0] for sourcefile
     @param args[1] for target file
   */
  public static void main(String[] args) throws IOException {
    // Check command-line parameter usage
    if (args.length != 2) {
      System.out.println(
        "Usage: java Copy sourceFile targetfile");
      System.exit(1);
    }

    // Check if source file exists
    File sourceFile = new File(args[0]);
    if (!sourceFile.exists()) {
       System.out.println("Source file " + args[0]
         + " does not exist");
       System.exit(2);
    }

    // Check if target file exists
    File targetFile = new File(args[1]);
    if (targetFile.exists()) {
      System.out.println("Target file " + args[1]
        + " already exists");
      System.exit(3);
    }

    try (
      // Create an input stream
      BufferedInputStream input =
        new BufferedInputStream(new FileInputStream(sourceFile));
 
      // Create an output stream
      BufferedOutputStream output =
        new BufferedOutputStream(new FileOutputStream(targetFile));
    ) {
      // Continuously read a byte from input and write it to output
      int r, numberOfBytesCopied = 0;
      while ((r = input.read()) != -1) {
        output.write((byte)r);
        numberOfBytesCopied++;
      }

      // Display the file size
      System.out.println(numberOfBytesCopied + " bytes copied");
    }
  }
}

//------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class TestObjectOutputStream {
  public static void main(String[] args) throws IOException {
    try ( // Create an output stream for file object.dat
      ObjectOutputStream output =
        new ObjectOutputStream(new FileOutputStream("object.dat"));
    ) {
      // Write a string, double value, and object to the file
      output.writeUTF("John");
      output.writeDouble(85.5);
      output.writeObject(new java.util.Date());
    }
  }
}

//--------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class TestObjectInputStream {
  public static void main(String[] args)
    throws ClassNotFoundException, IOException {
    try ( // Create an input stream for file object.dat
      ObjectInputStream input =
        new ObjectInputStream(new FileInputStream("object.dat"));
    ) {
      // Read a string, double value, and object from the file
      String name = input.readUTF();
      double score = input.readDouble();
      java.util.Date date = (java.util.Date)(input.readObject());
      System.out.println(name + " " + score + " " + date);
    }
  }
}

//----------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class TestObjectStreamForArray {
  public static void main(String[] args)
      throws ClassNotFoundException, IOException {
    int[] numbers = {1, 2, 3, 4, 5};
    String[] strings = {"John", "Susan", "Kim"};

    try ( // Create an output stream for file array.dat
      ObjectOutputStream output = new ObjectOutputStream(new
        FileOutputStream("array.dat", true));
    ) {
      // Write arrays to the object output stream
      output.writeObject(numbers);
      output.writeObject(strings);
    }

    try ( // Create an input stream for file array.dat
      ObjectInputStream input =
        new ObjectInputStream(new FileInputStream("array.dat"));
    ) {
      int[] newNumbers = (int[])(input.readObject());
      String[] newStrings = (String[])(input.readObject());
 
      // Display arrays
      for (int i = 0; i < newNumbers.length; i++)
        System.out.print(newNumbers[i] + " ");
      System.out.println();
 
      for (int i = 0; i < newStrings.length; i++)
        System.out.print(newStrings[i] + " ");
    }
  }
}

//----------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import java.io.*;

public class TestRandomAccessFile {
  public static void main(String[] args) throws IOException {
    try ( // Create a random access file
      RandomAccessFile inout = new RandomAccessFile("inout.dat", "rw");
    ) {
      // Clear the file to destroy the old contents if exists
      inout.setLength(0);
 
      // Write new integers to the file
      for (int i = 0; i < 200; i++)
        inout.writeInt(i);
 
      // Display the current length of the file
      System.out.println("Current file length is " + inout.length());
 
      // Retrieve the first number
      inout.seek(0); // Move the file pointer to the beginning
      System.out.println("The first number is " + inout.readInt());
 
      // Retrieve the second number
      inout.seek(1 * 4); // Move the file pointer to the second number
      System.out.println("The second number is " + inout.readInt());
 
      // Retrieve the tenth number
      inout.seek(9 * 4); // Move the file pointer to the tenth number
      System.out.println("The tenth number is " + inout.readInt());
 
      // Modify the eleventh number
      inout.writeInt(555);
 
      // Append a new number
      inout.seek(inout.length()); // Move the file pointer to the end
      inout.writeInt(999);
 
      // Display the new length
      System.out.println("The new length is " + inout.length());
 
      // Retrieve the new eleventh number
      inout.seek(10 * 4); // Move the file pointer to the eleventh number
      System.out.println("The eleventh number is " + inout.readInt());
    }
  }
}

//------------

Example 16

Chapter 16

//--------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.ContentDisplay;
import javafx.scene.control.Label;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.HBox;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;
import javafx.scene.shape.Ellipse;

public class LabelWithGraphic extends Application {
  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    ImageView us = new ImageView(new Image("image/us.gif"));
    Label lb1 = new Label("US\n50 States", us);
    lb1.setStyle("-fx-border-color: green; -fx-border-width: 2");
    lb1.setContentDisplay(ContentDisplay.BOTTOM);
    lb1.setTextFill(Color.RED);
 
    Label lb2 = new Label("Circle", new Circle(50, 50, 25));
    lb2.setContentDisplay(ContentDisplay.TOP);
    lb2.setTextFill(Color.ORANGE);

    Label lb3 = new Label("Retangle", new Rectangle(10, 10, 50, 25));
    lb3.setContentDisplay(ContentDisplay.RIGHT);
 
    Label lb4 = new Label("Ellipse", new Ellipse(50, 50, 50, 25));
    lb4.setContentDisplay(ContentDisplay.LEFT);

    Ellipse ellipse = new Ellipse(50, 50, 50, 25);
    ellipse.setStroke(Color.GREEN);
    ellipse.setFill(Color.WHITE);
    StackPane stackPane = new StackPane();
    stackPane.getChildren().addAll(ellipse, new Label("JavaFX"));
    Label lb5 = new Label("A pane inside a label", stackPane);
    lb5.setContentDisplay(ContentDisplay.BOTTOM);
 
    HBox pane = new HBox(20);
    pane.getChildren().addAll(lb1, lb2, lb3, lb4, lb5);

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 450, 150);
    primaryStage.setTitle("LabelWithGraphic"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.image.ImageView;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.text.Text;

public class ButtonDemo extends Application {
  protected Text text = new Text(50, 50, "JavaFX Programming");

  protected BorderPane getPane() {
    HBox paneForButtons = new HBox(20);
    Button btLeft = new Button("Left",
      new ImageView("image/left.gif"));
    Button btRight = new Button("Right",
      new ImageView("image/right.gif"));
    paneForButtons.getChildren().addAll(btLeft, btRight);
    paneForButtons.setAlignment(Pos.CENTER);
    paneForButtons.setStyle("-fx-border-color: green");

    BorderPane pane = new BorderPane();
    pane.setBottom(paneForButtons);
 
    Pane paneForText = new Pane();
    paneForText.getChildren().add(text);
    pane.setCenter(paneForText);
 
    btLeft.setOnAction(e -> text.setX(text.getX() - 10));
    btRight.setOnAction(e -> text.setX(text.getX() + 10));
 
    return pane;
  }

  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    // Create a scene and place it in the stage
    Scene scene = new Scene(getPane(), 450, 200);
    primaryStage.setTitle("ButtonDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//----------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.control.CheckBox;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.VBox;
import javafx.scene.text.Font;
import javafx.scene.text.FontPosture;
import javafx.scene.text.FontWeight;

public class CheckBoxDemo extends ButtonDemo {
  @Override // Override the getPane() method in the super class
  protected BorderPane getPane() {
    BorderPane pane = super.getPane();

    Font fontBoldItalic = Font.font("Times New Roman",
      FontWeight.BOLD, FontPosture.ITALIC, 20);
    Font fontBold = Font.font("Times New Roman",
      FontWeight.BOLD, FontPosture.REGULAR, 20);
    Font fontItalic = Font.font("Times New Roman",
      FontWeight.NORMAL, FontPosture.ITALIC, 20);
    Font fontNormal = Font.font("Times New Roman",
      FontWeight.NORMAL, FontPosture.REGULAR, 20);
 
    text.setFont(fontNormal);
 
    VBox paneForCheckBoxes = new VBox(20);
    paneForCheckBoxes.setPadding(new Insets(5, 5, 5, 5));
    paneForCheckBoxes.setStyle("-fx-border-color: green");
    CheckBox chkBold = new CheckBox("Bold");
    CheckBox chkItalic = new CheckBox("Italic");
    paneForCheckBoxes.getChildren().addAll(chkBold, chkItalic);
    pane.setRight(paneForCheckBoxes);

    EventHandler<ActionEvent> handler = e -> {
      if (chkBold.isSelected() && chkItalic.isSelected()) {
        text.setFont(fontBoldItalic); // Both check boxes checked
      }
      else if (chkBold.isSelected()) {
        text.setFont(fontBold); // The Bold check box checked
      }
      else if (chkItalic.isSelected()) {
        text.setFont(fontItalic); // The Italic check box checked
      }    
      else {
        text.setFont(fontNormal); // Both check boxes unchecked
      }
    };
 
    chkBold.setOnAction(handler);
    chkItalic.setOnAction(handler);
 
    return pane; // Return a new pane
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//-------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import static javafx.application.Application.launch;
import javafx.geometry.Insets;
import javafx.scene.control.RadioButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;

public class RadioButtonDemo extends CheckBoxDemo {
  @Override // Override the getPane() method in the super class
  protected BorderPane getPane() {
    BorderPane pane = super.getPane();
 
    VBox paneForRadioButtons = new VBox(20);
    paneForRadioButtons.setPadding(new Insets(5, 5, 5, 5));
    paneForRadioButtons.setStyle("-fx-border-color: green");
    paneForRadioButtons.setStyle
      ("-fx-border-width: 2px; -fx-border-color: green");
    RadioButton rbRed = new RadioButton("Red");
    RadioButton rbGreen = new RadioButton("Green");
    RadioButton rbBlue = new RadioButton("Blue");
    paneForRadioButtons.getChildren().addAll(rbRed, rbGreen, rbBlue);
    pane.setLeft(paneForRadioButtons);

    ToggleGroup group = new ToggleGroup();
    rbRed.setToggleGroup(group);
    rbGreen.setToggleGroup(group);
    rbBlue.setToggleGroup(group);
 
    rbRed.setOnAction(e -> {
      if (rbRed.isSelected()) {
        text.setFill(Color.RED);
      }
    });
 
    rbGreen.setOnAction(e -> {
      if (rbGreen.isSelected()) {
        text.setFill(Color.GREEN);
      }
    });

    rbBlue.setOnAction(e -> {
      if (rbBlue.isSelected()) {
        text.setFill(Color.BLUE);
      }
    });
 
    return pane;
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//-------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import static javafx.application.Application.launch;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.BorderPane;

public class TextFieldDemo extends RadioButtonDemo {
  @Override // Override the getPane() method in the super class
  protected BorderPane getPane() {
    BorderPane pane = super.getPane();
 
    BorderPane paneForTextField = new BorderPane();
    paneForTextField.setPadding(new Insets(5, 5, 5, 5));
    paneForTextField.setStyle("-fx-border-color: green");
    paneForTextField.setLeft(new Label("Enter a new message: "));
 
    TextField tf = new TextField();
    tf.setAlignment(Pos.BOTTOM_RIGHT);
    paneForTextField.setCenter(tf);
    pane.setTop(paneForTextField);
 
    tf.setOnAction(e -> text.setText(tf.getText()));
 
    return pane;
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//-------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.geometry.Insets;
import javafx.scene.control.Label;
import javafx.scene.control.ContentDisplay;
import javafx.scene.control.ScrollPane;
import javafx.scene.control.TextArea;
import javafx.scene.image.ImageView;
import javafx.scene.layout.BorderPane;
import javafx.scene.text.Font;

public class DescriptionPane extends BorderPane {
  /** Label for displaying an image and a title */
  private Label lblImageTitle = new Label();

  /** Text area for displaying text */
  private TextArea taDescription = new TextArea();

  public DescriptionPane() {
    // Center the icon and text and place the text under the icon
    lblImageTitle.setContentDisplay(ContentDisplay.TOP);
    lblImageTitle.setPrefSize(200,  100);
 
    // Set the font in the label and the text field
    lblImageTitle.setFont(new Font("SansSerif", 16));
    taDescription.setFont(new Font("Serif", 14));
 
 //   taDescription.setWrapText(true);
  //  taDescription.setEditable(false);

    // Create a scroll pane to hold the text area
    ScrollPane scrollPane = new ScrollPane(taDescription);

    // Place label and scroll pane in the border pane
    setLeft(lblImageTitle);
    setCenter(scrollPane);
    setPadding(new Insets(5, 5, 5, 5));
  }

  /** Set the title */
  public void setTitle(String title) {
    lblImageTitle.setText(title);
  }

  /** Set the image view */
  public void setImageView(ImageView icon) {
    lblImageTitle.setGraphic(icon);
  }

  /** Set the text description */
  public void setDescription(String text) {
    taDescription.setText(text);
  }
}

//-----------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;

public class TextAreaDemo extends Application {
  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    // Declare and create a description pane
    DescriptionPane descriptionPane = new DescriptionPane();

    // Set title, text and image in the description pane
    descriptionPane.setTitle("Canada");
    String description = "The Canadian national flag ...";
    descriptionPane.setImageView(new ImageView("image/ca.gif"));
    descriptionPane.setDescription(description);

    // Create a scene and place it in the stage
    Scene scene = new Scene(descriptionPane, 450, 200);
    primaryStage.setTitle("TextAreaDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//-------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.image.ImageView;
import javafx.scene.layout.BorderPane;

public class ComboBoxDemo extends Application {
  // Declare an array of Strings for flag titles
  private String[] flagTitles = {"Canada", "China", "Denmark",
      "France", "Germany", "India", "Norway", "United Kingdom",
      "United States of America"};

  // Declare an ImageView array for the national flags of 9 countries
  private ImageView[] flagImage = {new ImageView("image/ca.gif"),
      new ImageView("image/china.gif"),
      new ImageView("image/denmark.gif"),
      new ImageView("image/fr.gif"),
      new ImageView("image/germany.gif"),
      new ImageView("image/india.gif"),
      new ImageView("image/norway.gif"),
      new ImageView("image/uk.gif"), new ImageView("image/us.gif")};

  // Declare an array of strings for flag descriptions
  private String[] flagDescription = new String[9];

  // Declare and create a description pane
  private DescriptionPane descriptionPane = new DescriptionPane();

  // Create a combo box for selecting countries
  private ComboBox<String> cbo = new ComboBox<>(); // flagTitles);

  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    // Set text description
    flagDescription[0] = "The Canadian national flag ...";
    flagDescription[1] = "Description for China ... ";
    flagDescription[2] = "Description for Denmark ... ";
    flagDescription[3] = "Description for France ... ";
    flagDescription[4] = "Description for Germany ... ";
    flagDescription[5] = "Description for India ... ";
    flagDescription[6] = "Description for Norway ... ";
    flagDescription[7] = "Description for UK ... ";
    flagDescription[8] = "Description for US ... ";

    // Set the first country (Canada) for display
    setDisplay(0);

    // Add combo box and description pane to the border pane
    BorderPane pane = new BorderPane();
   
    BorderPane paneForComboBox = new BorderPane();
    paneForComboBox.setLeft(new Label("Select a country: "));
    paneForComboBox.setCenter(cbo);
    pane.setTop(paneForComboBox);
    cbo.setPrefWidth(400);
    cbo.setValue("Canada");
 
    ObservableList<String> items =
      FXCollections.observableArrayList(flagTitles);
    cbo.getItems().addAll(items);
    pane.setCenter(descriptionPane);
 
    // Display the selected country
    cbo.setOnAction(e -> setDisplay(items.indexOf(cbo.getValue())));
 
    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 450, 170);
    primaryStage.setTitle("ComboBoxDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /** Set display information on the description pane */
  public void setDisplay(int index) {
    descriptionPane.setTitle(flagTitles[index]);
    descriptionPane.setImageView(flagImage[index]);
    descriptionPane.setDescription(flagDescription[index]);
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//--------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.collections.FXCollections;
import javafx.scene.Scene;
import javafx.scene.control.ListView;
import javafx.scene.control.ScrollPane;
import javafx.scene.control.SelectionMode;
import javafx.scene.image.ImageView;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.FlowPane;

public class ListViewDemo extends Application {
  // Declare an array of Strings for flag titles
  private String[] flagTitles = {"Canada", "China", "Denmark",
    "France", "Germany", "India", "Norway", "United Kingdom",
    "United States of America"};

  // Declare an ImageView array for the national flags of 9 countries
  private ImageView[] ImageViews = {
    new ImageView("image/ca.gif"),
    new ImageView("image/china.gif"),
    new ImageView("image/denmark.gif"),
    new ImageView("image/fr.gif"),
    new ImageView("image/germany.gif"),
    new ImageView("image/india.gif"),
    new ImageView("image/norway.gif"),
    new ImageView("image/uk.gif"),
    new ImageView("image/us.gif")
  };

  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    ListView<String> lv = new ListView<>
      (FXCollections.observableArrayList(flagTitles));
    lv.setPrefSize(400, 400);
    lv.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
 
    // Create a pane to hold image views
    FlowPane imagePane = new FlowPane(10, 10);
    BorderPane pane = new BorderPane();
    pane.setLeft(new ScrollPane(lv));
    pane.setCenter(imagePane);

    lv.getSelectionModel().selectedItemProperty().addListener(
      ov -> {
        imagePane.getChildren().clear();
        for (Integer i: lv.getSelectionModel().getSelectedIndices()) {
          imagePane.getChildren().add(ImageViews[i]);
        }
    });

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 450, 170);
    primaryStage.setTitle("ListViewDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//---------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.geometry.Orientation;
import javafx.scene.Scene;
import javafx.scene.control.ScrollBar;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.Pane;
import javafx.scene.text.Text;

public class ScrollBarDemo extends Application {
  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    Text text = new Text(20, 20, "JavaFX Programming");
 
    ScrollBar sbHorizontal = new ScrollBar();
    ScrollBar sbVertical = new ScrollBar();
    sbVertical.setOrientation(Orientation.VERTICAL);
 
    // Create a text in a pane
    Pane paneForText = new Pane();
    paneForText.getChildren().add(text);
 
    // Create a border pane to hold text and scroll bars
    BorderPane pane = new BorderPane();
    pane.setCenter(paneForText);
    pane.setBottom(sbHorizontal);
    pane.setRight(sbVertical);

    // Listener for horizontal scroll bar value change
    sbHorizontal.valueProperty().addListener(ov ->
      text.setX(sbHorizontal.getValue() * paneForText.getWidth() /
        sbHorizontal.getMax()));
 
    // Listener for vertical scroll bar value change
    sbVertical.valueProperty().addListener(ov ->
      text.setY(sbVertical.getValue() * paneForText.getHeight() /
        sbVertical.getMax()));
 
    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 450, 170);
    primaryStage.setTitle("ScrollBarDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//---------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.geometry.Orientation;
import javafx.scene.Scene;
import javafx.scene.control.Slider;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.Pane;
import javafx.scene.text.Text;

public class SliderDemo extends Application {
  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    Text text = new Text(20, 20, "JavaFX Programming");
 
    Slider slHorizontal = new Slider();
    slHorizontal.setShowTickLabels(true);
    slHorizontal.setShowTickMarks(true);  
 
    Slider slVertical = new Slider();
    slVertical.setOrientation(Orientation.VERTICAL);
    slVertical.setShowTickLabels(true);
    slVertical.setShowTickMarks(true);
    slVertical.setValue(100);
 
    // Create a text in a pane
    Pane paneForText = new Pane();
    paneForText.getChildren().add(text);
 
    // Create a border pane to hold text and scroll bars
    BorderPane pane = new BorderPane();
    pane.setCenter(paneForText);
    pane.setBottom(slHorizontal);
    pane.setRight(slVertical);

    slHorizontal.valueProperty().addListener(ov ->
      text.setX(slHorizontal.getValue() * paneForText.getWidth() /
        slHorizontal.getMax()));
 
    slVertical.valueProperty().addListener(ov ->
      text.setY((slVertical.getMax() - slVertical.getValue())
        * paneForText.getHeight() / slVertical.getMax()));
 
    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 450, 170);
    primaryStage.setTitle("SliderDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//---------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.Slider;
import javafx.scene.layout.BorderPane;

public class BounceBallSlider extends Application {
  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    BallPane ballPane = new BallPane();
    Slider slSpeed = new Slider();
    slSpeed.setMax(20);
    ballPane.rateProperty().bind(slSpeed.valueProperty());
 
    BorderPane pane = new BorderPane();
    pane.setCenter(ballPane);
    pane.setBottom(slSpeed);
     
    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 250, 250);
    primaryStage.setTitle("BounceBallSlider"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//---------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Line;
import javafx.scene.shape.Ellipse;

public class TicTacToe extends Application {
  // Indicate which player has a turn, initially it is the X player
  private char whoseTurn = 'X';

  // Create and initialize cell
  private Cell[][] cell =  new Cell[3][3];

  // Create and initialize a status label
  private Label lblStatus = new Label("X's turn to play");

  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    // Pane to hold cell
    GridPane pane = new GridPane();
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        pane.add(cell[i][j] = new Cell(), j, i);

    BorderPane borderPane = new BorderPane();
    borderPane.setCenter(pane);
    borderPane.setBottom(lblStatus);
 
    // Create a scene and place it in the stage
    Scene scene = new Scene(borderPane, 450, 170);
    primaryStage.setTitle("TicTacToe"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /** Determine if the cell are all occupied */
  public boolean isFull() {
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        if (cell[i][j].getToken() == ' ')
          return false;

    return true;
  }

  /** Determine if the player with the specified token wins */
  public boolean isWon(char token) {
    for (int i = 0; i < 3; i++)
      if (cell[i][0].getToken() == token
          && cell[i][1].getToken() == token
          && cell[i][2].getToken() == token) {
        return true;
      }

    for (int j = 0; j < 3; j++)
      if (cell[0][j].getToken() ==  token
          && cell[1][j].getToken() == token
          && cell[2][j].getToken() == token) {
        return true;
      }

    if (cell[0][0].getToken() == token
        && cell[1][1].getToken() == token      
        && cell[2][2].getToken() == token) {
      return true;
    }

    if (cell[0][2].getToken() == token
        && cell[1][1].getToken() == token
        && cell[2][0].getToken() == token) {
      return true;
    }

    return false;
  }

  // An inner class for a cell
  public class Cell extends Pane {
    // Token used for this cell
    private char token = ' ';

    public Cell() {
      setStyle("-fx-border-color: black");
      this.setPrefSize(2000, 2000);
      this.setOnMouseClicked(e -> handleMouseClick());
    }

    /** Return token */
    public char getToken() {
      return token;
    }

    /** Set a new token */
    public void setToken(char c) {
      token = c;
   
      if (token == 'X') {
        Line line1 = new Line(10, 10,
          this.getWidth() - 10, this.getHeight() - 10);
        line1.endXProperty().bind(this.widthProperty().subtract(10));
        line1.endYProperty().bind(this.heightProperty().subtract(10));
        Line line2 = new Line(10, this.getHeight() - 10,
          this.getWidth() - 10, 10);
        line2.startYProperty().bind(
          this.heightProperty().subtract(10));
        line2.endXProperty().bind(this.widthProperty().subtract(10));
     
        // Add the lines to the pane
        this.getChildren().addAll(line1, line2);
      }
      else if (token == 'O') {
        Ellipse ellipse = new Ellipse(this.getWidth() / 2,
          this.getHeight() / 2, this.getWidth() / 2 - 10,
          this.getHeight() / 2 - 10);
        ellipse.centerXProperty().bind(
          this.widthProperty().divide(2));
        ellipse.centerYProperty().bind(
            this.heightProperty().divide(2));
        ellipse.radiusXProperty().bind(
            this.widthProperty().divide(2).subtract(10));      
        ellipse.radiusYProperty().bind(
            this.heightProperty().divide(2).subtract(10));
        ellipse.setStroke(Color.BLACK);
        ellipse.setFill(Color.WHITE);
     
        getChildren().add(ellipse); // Add the ellipse to the pane
      }
    }

    /* Handle a mouse click event */
    private void handleMouseClick() {
      // If cell is empty and game is not over
      if (token == ' ' && whoseTurn != ' ') {
        setToken(whoseTurn); // Set token in the cell

        // Check game status
        if (isWon(whoseTurn)) {
          lblStatus.setText(whoseTurn + " won! The game is over");
          whoseTurn = ' '; // Game is over
        }
        else if (isFull()) {
          lblStatus.setText("Draw! The game is over");
          whoseTurn = ' '; // Game is over
        }
        else {
          // Change the turn
          whoseTurn = (whoseTurn == 'X') ? 'O' : 'X';
          // Display whose turn
          lblStatus.setText(whoseTurn + "'s turn");
        }
      }
    }
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//----------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.stage.Stage;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.Slider;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Region;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaView;
import javafx.util.Duration;

public class MediaDemo extends Application {
  private static final String MEDIA_URL =
    "http://cs.armstrong.edu/liang/common/sample.mp4";

  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    Media media = new Media(MEDIA_URL);
    MediaPlayer mediaPlayer = new MediaPlayer(media);
    MediaView mediaView = new MediaView(mediaPlayer);

    Button playButton = new Button(">");
    playButton.setOnAction(e -> {
      if (playButton.getText().equals(">")) {
        mediaPlayer.play();
        playButton.setText("||");
      } else {
        mediaPlayer.pause();
        playButton.setText(">");
      }
    });

    Button rewindButton = new Button("<<");
    rewindButton.setOnAction(e -> mediaPlayer.seek(Duration.ZERO));
 
    Slider slVolume = new Slider();
    slVolume.setPrefWidth(150);
    slVolume.setMaxWidth(Region.USE_PREF_SIZE);
    slVolume.setMinWidth(30);
    slVolume.setValue(50);
    mediaPlayer.volumeProperty().bind(
      slVolume.valueProperty().divide(100));

    HBox hBox = new HBox(10);
    hBox.setAlignment(Pos.CENTER);
    hBox.getChildren().addAll(playButton, rewindButton,
      new Label("Volume"), slVolume);

    BorderPane pane = new BorderPane();
    pane.setCenter(mediaView);
    pane.setBottom(hBox);

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 650, 500);
    primaryStage.setTitle("MediaDemo"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage  
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//-----------------


Introduction to Java Programming, Tenth Edition, Y. Daniel Liang

import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.stage.Stage;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;

public class FlagAnthem extends Application {
  private final static int NUMBER_OF_NATIONS = 7;
  private final static String URLBase =
    "http://cs.armstrong.edu/liang/common";
  private int currentIndex = 0;
 
  @Override // Override the start method in the Application class
  public void start(Stage primaryStage) {
    Image[] images = new Image[NUMBER_OF_NATIONS];
    MediaPlayer[] mp = new MediaPlayer[NUMBER_OF_NATIONS];

    // Load images and audio
    for (int i = 0; i < NUMBER_OF_NATIONS; i++) {
      images[i] = new Image(URLBase + "/image/flag" + i + ".gif");
      mp[i] = new MediaPlayer(new Media(
        URLBase + "/audio/anthem/anthem" + i + ".mp3"));
    }

    Button btPlayPause = new Button(">");
    btPlayPause.setOnAction(e -> {
      if (btPlayPause.getText().equals(">")) {
        btPlayPause.setText("||");
        mp[currentIndex].pause();
      }
      else {
        btPlayPause.setText(">");
        mp[currentIndex].play();
      }
    });

    ImageView imageView = new ImageView(images[currentIndex]);
    ComboBox<String> cboNation = new ComboBox<>();
    ObservableList<String> items = FXCollections.observableArrayList
      ("Denmark", "Germany", "China", "India", "Norway", "UK", "US");
    cboNation.getItems().addAll(items);
    cboNation.setValue(items.get(0));
    cboNation.setOnAction(e -> {
      mp[currentIndex].stop();
      currentIndex = items.indexOf(cboNation.getValue());
      imageView.setImage(images[currentIndex]);
      mp[currentIndex].play();
    });

    HBox hBox = new HBox(10);
    hBox.getChildren().addAll(btPlayPause,
      new Label("Select a nation: "), cboNation);
    hBox.setAlignment(Pos.CENTER);

    // Create a pane to hold nodes
    BorderPane pane = new BorderPane();
    pane.setCenter(imageView);
    pane.setBottom(hBox);

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 350, 270);
    primaryStage.setTitle("FlagAnthem"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
  }

  /**
   * The main method is only needed for the IDE with limited
   * JavaFX support. Not needed for running from the command line.
   */
  public static void main(String[] args) {
    launch(args);
  }
}

//--------------