In JavaFX Script the modulus or remainder operator is represented by the keyword mod. The mod operator returns the remainder of a division operation. It can be applied to the Number and Integer data types. Listing 4-4 demonstrates the use of the modulus operator, and the code is self-explanatory.

var numMod  = 22.0  mod 7.0;
println("numMod = {numMod}");
var intMod = 22 mod 7;
println("intMod = {intMod}");

numMod = 1.0
intMod = 1

When an arithmetic operator is combined with an assignment operator, it is called an arithmetic assignment operator. This operator allows you to do the arithmetic and assignment operation in a single statement. The arithmetic assignment operators have the following syntax:

variable = variable arithmetic operator expression;

Using an arithmetic assignment operator is best suited for cases when a variable is used in an expression and the same variable is used to store the result of the expression. Here is a simple example:

x = x + 2;

The variable x is used in an arithmetic operation, and the same variable is used to store the value of the expression as well. So we are using the variable x twice. Using an arithmetic assignment operator, the same expression can be simplified as follows:

x+=2;

Both statements perform the same operation; that is, they increment the value of the variable x by 2. Similarly, other arithmetic operators can also be combined with the assignment operator to perform the respective arithmetic and assignment operations in a single statement.

Each operator is assigned a precedence or priority, which determines the order in which the operator operates on the operand. As in an ordinary arithmetic expression, multiplication and division have a higher precedence than addition and subtraction. If two operators have the same precedence, they are executed according to the order in which they appear in the statement. For most operators (except the assignment operator), the order is from left to right.

Let's look at an example to see how an expression is evaluated and in what order:

x = 20 + 50.0 * 7 / 2;

Since the multiplication (*) and division (/) operators have the highest precedence, they are executed first, followed by the addition (+) operation.

50.0 * 7               // since both * and / operators have the same precedence
                      and multiplication(*) is on the left side,
                      multiplication is done first, yielding the result 350.0.

350.0 / 2             // the next highest precedence is the / operator, so division is
                     done next, yielding the result 175.0.

20 + 175.0           // the final operator left in the expression is
                    addition (+), which yields the value 195.0, which
                     is the final value of the expression that is
                     assigned to 'x'

If you want to change the order of the execution, enclose the respective operator and the operands in parentheses. Let us rewrite the previous example as follows:

x =(20 + 50.0) * 7 / 2;

Now the operation (20 + 50.0) is evaluated first, since the parentheses take precedence over multiplication. You can see the operator precedence across all the JavaFX Script operators in Table 4.4, at the end of the "Operators" section.

A single operator operating on a single value is called a unary operator. The following unary operators are available in JavaFX Script:

The increment (++) and decrement (−−) operators perform a simple task. The first increments (increases) the value of its operand by 1 and the second decrements (decreases) the value of its operand by 1. There are two variants of each of these operators: prefix mode and postfix mode. Listing 4-5 shows the prefix and suffix syntax for unary increment operators and Listing 4-6 shows the prefix and suffix syntax for unary decrement operators.

++ variable;   // prefix form of Increment operator
variable ++;  // postfix form of Increment operator

-- variable;   // prefix form of decrement operator
variable -- // postfix form of decrement operator

In prefix mode the operator comes before the affected variable, and in postfix mode it comes after the variable. As demonstrated in the examples in Listing 4-7, the two modes differ in the timing at which the incrementing/ decrementing takes place.

1.    var x  : Integer = 10;
2.    var y = x++;
3.    var z = ++x;
4.    println("x = {x}  y = {y}  z = {z}");      // x = 12 y = 10  z = 12
5.    var p = x--;
6.    var q = --x;
7.    println("x = {x}  p = {p}  q = {q}");     // x = 10 p = 12 q = 10

x = 12  y = 10  z = 12
x = 10  p = 12  q = 10

In line 1, we declare a variable x and initialize its value to 10. In line 2, we are incrementing x using the postfix ++ operator and at the same time assigning the value of this expression to y. Looking at the line, you may assume that the value of y will be 11. But that is not correct because the value of the expression before the increment is assigned to y and x value is incremented afterward. Hence y will take the value of 10 and after this assignment; x will be incremented to 11.

Similarly, in line 3, we are assigning ++x to a variable z. Here x will be incremented first and then assigned to z. Hence, x increments from 11 to 12, and this value is assigned to z. This is the exact difference between prefix and postfix mode. In postfix mode, the expression is evaluated first and incremented or decremented after, whereas in postfix mode, the value is incremented/decremented first and then the expression is evaluated. Now you can apply the same logic to variables p and q as well.

Listing 4-8 provides another example of how prefix and postfix modes differ from each other.

1.    var x : Integer  = 7;
2.    println("initial value x = {x}");
3    println("postfix variant incrementng the value of x = {x++}");
4.    println("value x = {x}");
5.    println("prefix variant incrementng the value of x = {++x}");
6.    println("value x = {x}");

initial value x = 7
postfix variant incrementng the value of x = 7
value x = 8
prefix variant incrementng the value of x = 9
value x = 9

If you understood the example in Listing 4-7, you can easily predict the results for Listing 4-8 without looking at the output.

In line 1, we are declaring a variable x and initializing it with 7. In line 2, we are printing the value of x, which is 7. In line 3, we are incrementing x with the postfix increment operator and printing its value. Since postfix incrementing happens after the evaluation of the expression in which it is involved, println() is executed first, printing the actual value of x, which is 7. After the print operation, the value of x is incremented to 8. In line 4, we print the incremented value of x, which is 8. In line 5, we are again printing the x value and at the same time incrementing it using the prefix increment operator. Here the incrementing happens before the print() operation, so println() prints the incremented value of x, which is 9.

The same evaluation logic applies to the prefix and postfix decrement operator as well.

Hence, the choice between using prefix and postfix operators depends on the context—the actual expression in which the operator is involved and the expected value of the respective expression.

JavaFX Script variables can hold either positive numbers (by default all number are positive) or negative numbers. If you need to specify a number as negative, then you need to put a minus (−) sign in front of the value or the variable. The minus sign can be used to change the algebraic sign of a value or a variable:

var c = −10 ;

This example states that −10 is assigned to a variable c. In the same way, the value of an expression can be made negative by applying the minus sign in front of the expression, as in the following example:

var d  = - ( x * x  );

Here, the variable d will hold the negative value of the square of x.

As mentioned at the beginning of this section, there is also a unary + operator. Its use is implicit, since all numbers are positive by default.

The not operator is a unary operator used to complement either a relational or a logical expression. Listing 4-9 shows its syntax.

not logical or relational expression

The not operator negates the value of the logical or relational expression that follows it. If the expression evaluates to True, the not operator will change that to False and vice-versa. Listing 4-10 shows an example.

var a = 10;
var b = 5;
var x : Boolean = not ( a > b );
println(x);

false

As you see in the example, the actual value of the relational expression is true since a is greater than b. But the not operator changes that to false while assigning it to variable x.

Relational operators are used to compare the relationship between two operands. Relational expressions involving these operators always produce Boolean results and are often used in conditional expressions, as you will see later in this chapter. Table 4-2 shows the relational operators available in JavaFX Script.

var x  = 10 > 5;

Here we are comparing whether 10 is greater than 5. Since 10 is greater than 5, the value of x after executing the statement will be True. Since relational expressions fetch a Boolean result, the data type of x would automatically be inferred as Boolean by the compiler.

Logical operators are binary operators used to combine the value of two or more relational expressions. Similar to relational expressions, logical expressions also produce only Boolean results.

Table 4-3 shows the logical operators available in JavaFX Script.

Logical operators work as cutoff or short-circuit operators. For example, if an and operator combines two relational expressions to form a logical expression, and the relational expression on the left side evaluates to False, then the value of the whole logical expression evaluates to False and the right- side relational expression is not evaluated at all. In the same way, if an or logical operator combines two relational expressions and the left- side relational expression evaluates to True, then the right expression is ignored and the value of the whole logical expression becomes True.

Here is an example of how two relational expressions are combined with a logical operator:

var x = ( 10 > 5 and 2 < 5 );
var firstGrade = ( totalMark => 60 or totalMarks <= 80 );

Besides using variables or data values as you've seen, the relational expressions combined by the logical operators can also include complex expressions as well.

Table 4-4 summarizes the operator precedence for all the operators available in JavaFX Script.

A range expression defines a sequence of numeric values forming an arithmetic series, using the syntax shown in Listing 4-11.

[number1..number2]

A range expression defines a sequence whose elements consist of the integers from number1 to number2 inclusive. The following example shows a simple range expression.

var nums = [0..3];
      println (nums);

Output

[ 0, 1, 2, 3 ]

A range expression must have a starting and an ending value and may optionally specify a step value, to define the number by which the sequence must be incremented. The default step value of 1 is used if none is specified. The following example would redefine the previous range with a step value of 2.

var nums = [0..3 step 2];
      println (nums);

Output

[ 0,  2]

Here, the resulting sequence just includes 0, 2 and not the final value. When there is a step value, first the starting value is included in the sequence and then the step factor is applied repeatedly until the end value is reached. Note that the end value 3 is not included here since it does not meet the step criteria.

The range expression can be pictorially represented as shown in Figure 4-1.

Figure 4.1. The range expression

In this diagram, the three valueExpressions must be of either type Integer or Number. If any of them is of type Number, the rangeExpression will become a sequence of Numbers.

Table 4-5 shows examples of range expressions with corresponding output values.

A block is a collection of definitions and/or expressions surrounded by curly braces and separated by semicolons. The value of the block expression is the value of the last expression in the block. If the last statement is not an expression, then the value of the block is Void. Listing 4-12 shows an example.

println( {
      var sum = 0;
         var counter = 10;
         while (counter > 0) {
                sum += counter;
                --counter;
        }
         "Sum is {sum}"
      } );

Sum is 55

As you can see, the value of the block enclosed within the println() is the value of the last expression, which is Sum is {sum}.

Listing 4-13 illustrates a conditional block expression.

var flag: Boolean = true;
var x = if (flag) {
45 * 2 + 10;
} else {
90 * 2 + 20;
}
println(x);

100  (if flag value is true as given in the code)
200 (if flag value is changed to false)

Here, the value of the if and else blocks takes the value of the arithmetic expression defined within the block since that is the last (only) expression in the block. Please note that the variables declared within a block can be used only in that block or in its child blocks, since they are local to the block.

While expressions are the same in JavaFX Script as in Java. The expression specified after the close parenthesis repeats as long as the Boolean expression controlling the while loop evaluates to True. Listing 4-20 shows a simple example of a while loop, and the code is self-explanatory.

var i = 0;
while (i < 5) {
println(i);
i ++;
}

0
1
2
3
4

A while expression can be pictorially represented as shown in Figure 4-4.

Figure 4.4. The while expression

In Figure 4-4, valueExpression yields a binary value (True or False), based on which the execution of the while loop is repeated. Unlike a for expression, the value of the while expression is always Void and hence it cannot be used in assignments like for expressions.

The continue expression is the same in JavaScript as in Java. It abruptly completes the current iteration of the loop in which it is lexically contained and attempts to start the next iteration. The statements that follow continue won't be executed and control is transferred to the top of the loop. Listing 4-23 demonstrates a continue expression.

var notPrime = false;
for (x in [2..100]) {

    for (y in [2..(x-1)]) {

        if (x mod y == 0) {

            notPrime = true;

            break;

        }

    }

    if (notPrime) {

notPrime = false;
continue;
    } else {

        print("{x} ");

    }

}

2 3 5 7 11S 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

This example is self-explanatory. However, note that the value of continue is also always Void.

The if-else expression in JavaFX Script is pretty much the same as in Java. If-else is probably the most basic way of controlling program flow. The if-else expression in JavaFX Script uses the truth or falsehood of the associated conditional expression to decide the program flow. If the conditional expression evaluates to True, the first block of code or the expression following the conditional expression is executed. If the conditional expression evaluates to false, the else block is executed.

The if-else expression can be pictorially represented as shown in Figure 4-5.

Figure 4.5. The if-else expression

As described in Figure 4-5, the else and then parts of the if-else expression are optional.

The value of an if expression can either be a valid value or Void depending on the value that the first and second expressions evaluate to. If the else part is present and if neither of the expressions are of the Void type, then the if expression will have a valid value. The value will be that of the first expression if valueExpression evaluates to True and will be that of the second if valueExpression is False. If the valueExpression is False and if there is no else block, the value of the if expression would be Void.

Listing 4-24 shows a simple if-else expression.

var mark: Integer = 60;
if (mark >= 50) {
println("PASS");
} else {
println ("FAIL");
}

PASS

The same expression can alternatively be specified in one statement, as shown in the following example. Here we omit the braces since there is only one statement in each of the blocks.

If (mark >= 50) println("PASS") else println("FAIL");

Since the value of mark is 60, this will print PASS. If the mark value is changed to anything less than 50, then the else block will be executed, printing FAIL. The value of the if expression as such would be Void since neither of the expressions have a valid value here.

Since the if-else expression can bear a value, it can be used to assign a value to a variable conditionally, as shown in Listing 4-25.

var flag = true;
var x = if (flag) "JavaFX" else 3.14;
println(x);

JavaFX

This result occurs because flag is set to True. If the ) flag value is changed to false, the output would be 3.14.

In Listing 4-25, the type of the variable x would be an Object here as there is no more specific type that has String and Number as sub-types.

When using if-else expressions for assignments, you have to ensure there is an else part and both the expressions given under if and else yield valid values. If not, this would result in a compilation error.

Exception handling in JavaFX Script is almost the same as in Java. The same try-catch-finally blocks used in Java are applicable to JavaFX Script as well but need to be written with JavaFX Script variable declaration syntax.

Listing 4-26 shows a simple example of how the try-catch-finally is written in JavaFX Script.

try {
    throw new Exception("Demonstrating try-catch-finally");
} catch (e:Exception) {
    println("Exception thrown {e}");
        } finally {
        println("finally reached");
}

Listing 4-26 could also be written as follows:

try {
    throw new Exception("Demonstrating try-catch-finally");
} catch (any) {
    println("Exception thrown {any}");
        } finally {
        println("finally reached");
}

Output

Exception thrown java.lang.Exception: Demonstrating try-catch-finally
finally reached

Listing 4-26 throws an exception intentionally from within the try block to see if it is caught by the respective catch block. As you see in the output, the respective catch block as well as the finally block are called when the exception is thrown. Now let us see in detail how this works in JavaFX Script.

The typical try-catch-finally and throw clauses in JavaFX Script are pictorially described in Figures 4-6 through 4-8. First, Figure 4-6 shows the complete try-catch-finally structure.

Figure 4.6. The try expression

The try block (Figure 4-6) is executed until either an exception is thrown or it finishes successfully. When there is an exception, each catch clause is inspected to see which of the catch block's formalParameters matches that of the exception thrown. Figure 4-7 represents the catch block pictorially.

Figure 4.7. The catch expression

If any of the catch blocks is tuned to receive the exception thrown, the respective block is executed, with formalParameter replaced with the exception object. No further catch blocks will be executed. If none of the catch blocks match the exception thrown, then the exception propagates out of the try-catch-finally blocks.

A finally block, if present, will always be executed after the try block regardless of whether any exception is thrown.

The throw expression in JavaFX Script (Figure 4-8) is same as in Java and causes an exception to be thrown. Since it completes abruptly, it does not have any value.

Figure 4.8. The throw expression

A try expression does not have any value and hence it is of type Void.

A new expression is used to create instance of a Java class. It allows us to specify the parameters required by the constructor of the respective Java class. Figure 4-9 is a diagram of its syntax, and listing 4-27 shows some examples of the new operator to create instances of Java classes.

Figure 4.9. The new expression

var f = new java.io.File("JavaFX.txt");
var fis: java.io.FileInputStream = new java.io.FileInputStream("Sun.doc");
var str = new java.lang.String("JavaFX is cool");

Instances of JavaFX classes can also be created with the new operator, but it is recommended to use object literals for JavaFX class instances. You will see more about object literals when we deal with class definitions in JavaFX Script.

In JavaFX Script, one expression must be differentiated from another by a semicolon, without which there will be a compilation error. Listing 4-28 shows good and bad examples.

println(n) // This line would show a compilation error for missing semicolon
var xx = 9; // Correct
var yy = 100 // This will not show a compilation error since there are no expressions following this one.

You have forgotten the ';', which is needed to separate one expression from the next.
println(n)
      ^

Hence it is important to close an expression with a semicolon (;) when there are further expressions following it.