BlogJava-asdtiang-java study-文章分类-java fx学习笔记

JAVA FX语法学习----数据绑定和触发器

asdtiang — Fri, 15 Jan 2010 06:35:00 GMT

bind 关键字将目标变量的值与绑定表达式的值相关联。绑定表达式可以是某个基本类型的简单值、对象、函数的结果或表达式的结果。以下几节分别提供每种绑定表达式的示例。

在大多数实际的编程情况下，需要通过数据绑定使应用程序的图形用户界面 (Graphical User Interface, GUI) 与其底层数据同步。（GUI 编程是使用 JavaFX 构建 GUI 应用程序的主题；下面我们将用一些非可视的示例来说明基本的底层结构。）

让我们先看一个简单的示例：下面的脚本将变量 x 绑定到变量 y，更改 x 的值，然后输出 y 的值。由于这两个变量绑定在一起，因此 y 值会自动更新为新值。

var x = 0;

            

            def y = bind x;

            

            x = 1;

            

            println(y); // y now equals 1

            

            x = 47;

            

            println(y); // y now equals 47

请注意，我们已将变量 y 声明为 def。这可防止任何代码直接为该变量赋值（尽管允许该变量的值因绑定 (bind) 而更改）。在绑定到对象时，此约定仍适用（请回顾使用对象中介绍的 Address）：

var myStreet = "1 Main Street";

            

            var myCity = "Santa Clara";

            

            var myState = "CA";

            

            var myZip = "95050";

            

            

            

            def address = bind Address {

            

            street: myStreet;

            

            city: myCity;

            

            state: myState;

            

            zip: myZip;

            

            };

            

            

            

            println("address.street == {address.street}");

            

            myStreet = "100 Maple Street";

            

            println("address.street == {address.street}");

如果更改 myStreet 的值，address 对象内部的 street 变量将受到影响：

address.street == 1 Main Street

            

            address.street == 100 Maple Street

请注意，更改 myStreet 的值实际上会导致创建一个新的 Address 对象，然后将该对象重新赋给 address 变量。为了跟踪所做的更改而不创建新的 Address 对象，请改为直接绑定 (bind) 到该对象的实例变量：

def address = bind Address {

            

            street: bind myStreet;

            

            city: bind myCity;

            

            state: bind myState;

            

            zip: bind myZip;

            

            };

如果要显式绑定到实例变量，还可以省略第一个 bind（Address 前面的那个）：

def address = Address {

            

            street: bind myStreet;

            

            city: bind myCity;

            

            state: bind myState;

            

            zip: bind myZip;

            

            };

绑定和函数

前面的课程已讲授了函数，但是您还必须了解绑定函数与非绑定函数之间的区别。

请考虑下面的函数，该函数创建和返回一个 Point 对象：

var scale = 1.0;

            

            

            

            bound function makePoint(xPos : Number, yPos : Number) : Point {

            

            Point {

            

            x: xPos * scale

            

            y: yPos * scale

            

            }

            

            }

            

            

            

            class Point { 

            

            var x : Number;

            

            var y : Number;

            

            }

这就是所谓的绑定函数，因为它前面有 bound 关键字。

注意：bound 关键字不能替换 bind 关键字；这两个关键字按如下所示方式结合使用。

接下来，让我们添加一些代码来调用此函数并测试绑定：

var scale = 1.0;

            

            

            

            bound function makePoint(xPos : Number, yPos : Number) : Point {

            

            Point {

            

            x: xPos * scale

            

            y: yPos * scale

            

            }

            

            }

            

            

            

            class Point {

            

            var x : Number;

            

            var y : Number;

            

            }

            

            

            

            var myX = 3.0;

            

            var myY = 3.0;

            

            def pt = bind makePoint(myX, myY);

            

            println(pt.x);

            

            

            

            myX = 10.0;

            

            println(pt.x);

            

            

            

            scale = 2.0;

            

            println(pt.x);

此脚本的输出如下所示：

让我们分析一下此脚本（一次分析一部分）。

代码：

var myX = 3.0;

            

            var myY = 3.0;

            

            def pt = bind makePoint(myX, myY);

            

            println(pt.x);

将脚本变量 myX 和 myY 初始化为 3.0。这些值随后作为参数传递给 makePoint 函数，该函数会创建并返回一个新的 Point 对象。bind 关键字（位于 makePoint 调用前面）将新创建的 Point 对象 (pt) 绑定到 makePoint 函数的结果。

接下来，代码：

myX = 10.0;

            

            println(pt.x);

将 myX 的值更改为 10.0 并输出 pt.x 的值。输出表明 pt.x 现在也为 10.0。

最后，代码：

scale = 2.0;

            

            println(pt.x);

更改 scale 的值并再次输出 pt.x 的值。pt.x 的值现在为 20.0。但是，如果我们从该函数中删除 bound 关键字（从而使其成为非绑定函数），则输出应为：

这是因为，非绑定函数只是在其某个参数发生变化时才被重新调用。由于 scale 不是函数的参数，因此更改它的值将不会导致另一个函数调用。

对序列进行绑定

您还可以将 bind 与 for 表达式结合使用。为了对此进行研究，让我们首先定义两个序列并输出这两个序列中各个项的值：

var seq1 = [1..10];

            

            def seq2 = bind for (item in seq1) item*2;

            

            printSeqs();

            

            

            

            function printSeqs() {

            

            println("First Sequence:");

            

            for (i in seq1){println(i);}

            

            println("Second Sequence:");

            

            for (i in seq2){println(i);}

            

            }

seq1 包含十个项（数字 1 至 10）。seq2 也包含十个项；这些项本来会与 seq1 具有相同的值，但是我们已经对其中的每个项都应用了表达式 item*2，因此它们的值将加倍。

因此，输出为：

First Sequence:

            

            1

            

            2

            

            3

            

            4

            

            5

            

            6

            

            7

            

            8

            

            9

            

            10

            

            Second Sequence:

            

            2

            

            4

            

            6

            

            8

            

            10

            

            12

            

            14

            

            16

            

            18

            

            20

我们可以通过将 bind 关键字放在 for 关键字前面来绑定这两个序列。

def seq2 = bind for (item in seq1) item*2;

问题现在变成：“如果 seq1 发生了某些变化，那么是 seq2 中的所有项都受到影响还是部分项受到影响？”我们可以通过以下方法来对此进行测试：将一个项（值 11）插入 seq1 的末尾处，然后输出这两个序列的值，看有什么变化：

var seq1 = [1..10];

            

            def seq2 = bind for (item in seq1) item*2;

            

            insert 11 into seq1;

            

            printSeqs();

            

            

            

            function printSeqs() {

            

            println("First Sequence:");

            

            for (i in seq1){println(i);}

            

            println("Second Sequence:");

            

            for (i in seq2){println(i);}

            

            }

输出：

First Sequence:

            

            1

            

            2

            

            3

            

            4

            

            5

            

            6

            

            7

            

            8

            

            9

            

            10

            

            11

            

            Second Sequence:

            

            2

            

            4

            

            6

            

            8

            

            10

            

            12

            

            14

            

            16

            

            18

            

            20

            

            22

输出表明，将 11 插入 seq1 的末尾处不会影响 seq2 中的前 10 个项；新项会自动添加到 seq2 的末尾处，其值为 22。

替换触发器

替换触发器是附加到变量的任意代码块，一旦变量的值发生变化，它们就会执行。以下示例显示了基本语法：它定义一个 password 变量并向其附加一个替换触发器；当密码发生变化时，该触发器会输出一则消息来报告此变量的新值：

var password = "foo" on replace oldValue {

            

            println(""nALERT! Password has changed!");

            

            println("Old Value: {oldValue}");

            

            println("New Value: {password}");

            

            };

            

            

            

            password = "bar";

此示例的输出如下所示：

ALERT! Password has changed!

            

            Old Value: 

            

            New Value: foo

            

            

            

            ALERT! Password has changed!

            

            Old Value: foo

            

            New Value: bar

此示例中的触发器引发两次：当 password 初始化为 "foo" 时引发一次，当其值变成 "bar" 时又引发一次。请注意，oldValue 变量存储在调用触发器之前变量的值。您可以将 oldValue 变量命名为任何所需的名称，我们是由于该名称具有描述性才恰好使用它。

asdtiang 2010-01-15 14:35 发表评论

JAVA FX语法学习----表达式

asdtiang — Fri, 15 Jan 2010 06:23:00 GMT

表达式是可以生成某个结果值的代码段，可以结合使用表达式来生成“更大的”表达式。JavaFX Script 编程语言是表达式语言，这意味着一切（包括循环、条件甚至块）都是表达式。在某些情况下（如 while 表达式），表达式具有 Void 类型，这意味着它们不返回结果值

块表达式

块表达式由一系列声明或表达式组成，它们括在花括号中并用分号进行分隔。块表达式的值是最后一个表达式的值。如果块表达式中不包含表达式，则其类型为 Void。请注意，var 和 def 是表达式。

下面的块表达式对几个数字进行相加并将结果存储在一个名为 total 的变量中：

var nums = [5, 7, 3, 9];

            var total = {

            var sum = 0;

            for (a in nums) { sum += a };

            sum;

            }

            println("Total is {total}.");

运行此脚本将生成以下输出：

Total is 24.

第一行 (var nums = [5, 7, 3, 9];) 声明一个整数序列。

第二行声明一个名为 total 的变量，该变量将用来存放这些整数的和。

随后的块表达式由左花括号和右花括号之间的所有内容构成：

{

            var sum = 0;

            for (a in nums) { sum += a };

            sum;

            }

在该块内部，第一行代码声明一个名为 sum 的变量，该变量将用来存放此序列中各个数字之和。第二行（一个 for 表达式）遍历该序列，将每个数字与 sum 相加。最后一行设置该块表达式的返回值（在本例中为 24）。

if 表达式

使用 if 表达式后，仅当特定条件为真时才执行某些代码块，从而对程序流进行定向。

例如，以下脚本基于年龄来设置票价。12 岁到 65 岁的人支付正常价 10 美元。老人和儿童支付 5 美元；5 岁以下的儿童免费。

def age = 8;

            var ticketPrice;

            

            if (age < 5 ) {

            ticketPrice = 0;

            } else if (age < 12 or age > 65) {

            ticketPrice = 5;

            } else {

            ticketPrice = 10;

            }

            println("Age: {age} Ticket Price: {ticketPrice} dollars.");

如果将 age 设置为 8，该脚本将生成以下输出：

Age: 8 Ticket Price: 5 dollars.

该示例的程序流如下所示：

if (age < 5 ) {

            ticketPrice = 0;

            } else if (age < 12 or age > 65) {

            ticketPrice = 5;

            } else {

            ticketPrice = 10;

            }

如果 age 小于 5，则票价将设置为 0。

程序随后将跳过其余条件测试并输出结果。

如果 age 不小于 5，程序将继续执行下一个条件测试（由后跟另一个 if 表达式的 else 关键字来指示）：

if (age < 5 ) {

            ticketPrice = 0;

            } else if (age < 12 or age > 65) {

            ticketPrice = 5;

            } else {

            ticketPrice = 10;

            }

如果人的年龄在 5 到 12 岁之间或者大于 65 岁，该程序会将票价设置为 5 美元。

如果人的年龄在 12 到 65 岁之间，程序会流至最后一个代码块（用 else 关键字进行标记）：

if (age < 5 ) {

            ticketPrice = 0;

            } else if (age < 12 or age > 65) {

            ticketPrice = 5;

            } else {

            ticketPrice = 10;

            }

只有当前面的所有条件均不满足时，才会执行此块。它会针对 12 到 65 岁之间的人将票价设置为 10 美元。

注：可以将上面的代码缩减成一个非常简洁的条件表达式：
ticketPrice = if (age < 5) 0 else if (age < 12 or age > 65) 5 else 10;
这是一个需要掌握的有用方法，在本教程的后面部分中还会使用它。

范围表达式

“序列”一课讲授了一种用来声明形成等差数列的数字序列的简化表示法。

var num = [0..5];

从技术上讲，[0..5] 是一个范围表达式。默认情况下，相邻值之间的间隔为 1，但是您可以使用 step 关键字来指定一个不同的间隔。例如，定义一个由 1 到 10 之间的奇数构成的序列：

var nums = [1..10 step 2];

            println(nums);

此脚本的输出如下所示：

[ 1, 3, 5, 7, 9 ]

要创建降序范围，请确保第二个值小于第一个值，并指定一个负的 step 值：

var nums = [10..1 step -1];

            println(nums);

输出为：

[ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]

如果您在创建降序范围时没有提供负的 step 值，则会生成一个空序列。

以下代码：

var nums = [10..1 step 1];

            println(nums);

将生成下面的编译时警告：

range.fx:1: warning: empty sequence range literal, probably not what you meant.

            var nums = [10..1 step 1];

            ^

            1 warning

如果您完全忽略 step 值，也会生成一个空序列。

for 表达式

另一个与序列有关的表达式是 for 表达式。for 表达式为遍历序列中的各个项提供了一种方便的机制。

以下代码提供了一个示例：

var days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            

            for (day in days) {

            println(day);

            }

此脚本的输出如下所示：

让我们将该示例分成几个部分。for 表达式以 "for" 关键字开头：

for (day in days) {

            println(day);

            }

days 变量是要由 for 表达式处理的输入序列的名称：

for (day in days) {

            println(day);

            }

当 for 表达式遍历该序列时，day 变量用来存放当前项：

for (day in days) {

            println(day);

            }

请注意，不需要在脚本中的其他位置声明 day 变量即可将其用在 for 表达式中。此外，在完成整个循环之后，将无法访问 day。程序员通常会赋予临时变量（如该变量）非常短的名称（或由一个字母构成的名称）。

在上例中，未显示 for 返回值；但 for 也是一个返回序列的表达式。以下代码显示了两个使用 for 表达式从另一个序列创建序列的示例：

// Resulting sequence squares the values from the original sequence.

            var squares = for (i in [1..10]) i*i; 

            

            // Resulting sequence is ["MON", "TUE", "WED", and so on...]

            var capitalDays = for (day in days) day.toUpperCase();

请注意，toUpperCase 函数由 String 对象提供。您可以通过查阅 API 文档来查看完整的可用函数列表。

while 表达式

另一个循环结构是 while 表达式。与作用于序列中项的 for 表达式不同，while 表达式会一直循环，直到给定的表达式为 false 为止。尽管 while 在语法上是表达式，但是它的类型为 Void，不返回值。

下面提供了一个示例：

var count = 0;

            while (count < 10) {

            println("count == {count}");

            count++;

            }

此脚本的输出如下所示：

count == 0

            count == 1

            count == 2

            count == 3

            count == 4

            count == 5

            count == 6

            count == 7

            count == 8 

            count == 9

第一行声明一个名为 count 的变量并将其初始化为 0：

var count = 0;

            while (count < 10) {

            println("count == {count}");

            count += 1;

            }

第二行以 while 表达式开头。此表达式创建了一个循环（在左花括号和右花括号之间），该循环会一直进行，直到 count < 10 的值为 false 为止：

var count = 0;

            while (count < 10) {

            println("count == {count}");

            count += 1;

            }

While 表达式的主体会输出 count 的当前值，然后将 count 的值加 1：

var count = 0;

            while (count < 10) { 

            println("count == {count}");

            count += 1;

            }

当 count 等于 10 时，循环退出。要创建一个无限循环，请将 true 关键字放在左小括号和右小括号之间，如 while(true){} 中所示。

break 和 continue 表达式

break 和 continue 表达式与循环表达式有关。这两个表达式会影响循环迭代：break 完全放弃循环，而 continue 仅放弃当前迭代。

尽管 break 和 continue 在语法上是表达式，但它们的类型为 Void，不返回值。

示例：

for (i in [0..10]) {

            if (i > 5) {

            break;

            }

            

            if (i mod 2 == 0) {

            continue;

            }

            

            println(i);

            }

输出：

如果没有 if 表达式，该程序将只是输出 0 到 10 之间的数字。

如果只有第一个 if 表达式，程序将在 i 的值大于 5 时中断循环：

if (i > 5) {

            break;

            }

因此，程序将仅输出 1 到 5 之间的数字。

通过添加第二个 if 表达式，程序将仅放弃循环的当前迭代而继续执行下一个迭代：

if (i mod 2 == 0) {

            continue;

            }

在这种情况下，只有当 i 为偶数（即 i 能被 2 整除，没有余数）时才执行 continue。出现这种情况时，将永远不会调用 println()，因此输出中将不包含该数字。

throw、try、catch 和 finally 表达式

在实际的应用程序中，正常的脚本执行流有时会被某个事件中止。例如，如果脚本从某个文件中读取输入，但是找不到该文件，该脚本将无法继续。我们将这种情况称为“异常”。

注意：异常是对象。它们的类型通常以它们所表示的情况命名（例如，FileNotFoundException 表示找不到文件的情况）。但是，定义一组特定于即将给出的示例的异常不在本节的讨论范围之内。因此，我们将使用一个通用的 Exception 对象（从 Java 编程语言借用而来）来说明 throw、try、catch 和 finally 表达式。

以下脚本定义（和调用）一个会抛出异常的函数：

import java.lang.Exception;

            

            foo();

            

            println("The script is now executing as expected... ");

            

            function foo() {

            var somethingWeird = false;

            

            if(somethingWeird){

            throw new Exception("Something weird just happened!");

            } else {

            println("We made it through the function.");

            }

            }

按原样运行此脚本（将 somethingWeird 设置为 false）将输出以下消息：

We made it through the function.

            The script is now executing as expected...

但是，如果将该变量更改为 true，则会抛出异常。在运行时，该脚本将崩溃并显示以下消息：

Exception in thread "main" java.lang.Exception: Something weird just happened!

            at exceptions.foo(exceptions.fx:10)

            at exceptions.javafx$run$(exceptions.fx:3)

为了防止崩溃，我们将需要使用 try/catch 表达式来包装 foo() 调用。顾名思义，这些表达式尝试执行某些代码，但会在出现问题时捕捉异常：

try {

            foo();

            } catch (e: Exception) {

            println("{e.getMessage()} (but we caught it)");

            }

现在，程序不会崩溃，而只是输出：

Something weird just happened! (but we caught it)

            The script is now executing as expected...

还有一个 finally 块（它在技术上不是表达式），无论是否抛出了异常，该块始终在 try 表达式退出之后的某个时间执行。finally 块用来执行无论 try 主体是成功还是抛出异常都需要执行的清除操作。

try {

            foo();

            } catch (e: Exception) {

            println("{e.getMessage()} (but we caught it)");

            } finally {

            println("We are now in the finally expression...");

            }

程序输出现在为：

Something weird just happened! (but we caught it)

We are now in the finally expression...

The script is now executing as expected...

asdtiang 2010-01-15 14:23 发表评论

JAVA FX语法学习----运算符

asdtiang — Fri, 15 Jan 2010 05:03:00 GMT

赋值运算符

赋值运算符 "=" 是您将遇到的最常用的运算符。使用该运算符可以将其右侧的值赋给其左侧的操作数：

result = num1 + num2;

            

            

            

            days = ["Mon","Tue","Wed","Thu","Fri"];

算术运算符

使用算术运算符可以执行加、减、乘和除运算。mod 运算符用一个操作数除以另一个操作数并将余数作为结果返回。

+ （加运算符）

            

            

            

            - （减运算符）

            

            

            

            * （乘运算符）

            

            

            

            / （除运算符）

            

            

            

            mod （求余运算符）

以下脚本提供了一些示例：

var result = 1 + 2; // result is now 3

            

            

            

            println(result);

            

            

            

            

            

            

            

            result = result - 1; // result is now 2

            

            

            

            println(result);

            

            

            

            

            

            

            

            result = result * 2; // result is now 4

            

            

            

            println(result);

            

            

            

            

            

            

            

            result = result / 2; // result is now 2

            

            

            

            println(result);

            

            

            

            

            

            

            

            result = result + 8; // result is now 10

            

            

            

            println(result);

            

            

            

            

            

            

            

            result = result mod 7; // result is now 3

            

            

            

            println(result);

您还可以结合使用算术运算符与赋值运算符来创建复合赋值。例如，result += 1; 和 result = result+1; 都会将 result 的值加 1。

var result = 0;

            

            

            

            result += 1;

            

            

            

            println(result); // result is now 1

            

            

            

            

            

            

            

            result -= 1;

            

            

            

            println(result); // result is now 0

            

            

            

            

            

            

            

            result = 2;

            

            

            

            result *= 5; // result is now 10

            

            

            

            println(result);

            

            

            

            

            

            

            

            result /= 2; // result is now 5

            

            

            

            println(result);

唯一不能按照此方式使用的算术运算符是 mod。例如，如果您希望将 result 除以 2，然后将余数重新赋给其自身，则需要编写：result = result mod 2;

一元运算符

大多数运算符都需要两个操作数，而一元运算符仅使用一个操作数来执行诸如按一递增/递减某个值、对某个数字求反或对布尔值求反之类的操作。

-  一元减运算符；对某个数字求反

            

            

            

            ++   递增运算符；按 1 递增某个值

            

            

            

            --     递减运算符；按 1 递减某个值

            

            

            

            not    逻辑求补运算符；对布尔值求反

以下脚本用于测试一元运算符：

var result = 1; // result is now 1

            

            

            

            

            

            

            

            result--;  // result is now 0

            

            

            

            println(result);

            

            

            

            

            

            

            

            result++; // result is now 1

            

            

            

            println(result);

            

            

            

            

            

            

            

            result = -result; // result is now -1

            

            

            

            println(result);

            

            

            

            

            

            

            

            var success = false;

            

            

            

            println(success); // false

            

            

            

            println(not success); // true

递增/递减运算符可以在操作数之前（前缀）或之后（后缀）应用。代码 result++; 和 ++result; 都将导致 result 的值加 1。二者之间的唯一区别就是前缀版本 (++result) 得到的是递增后的值，而后缀版本 (result++) 得到的是原始值。（您可以通过以下方法来记忆：++result 先执行递增再获得值，而 result++ 先获得值再执行递增。）如果您只是执行简单的递增/递减，则选择哪个版本都一样。但是，如果您将该运算符作为较大表达式的一部分进行使用，则选择不同的版本会对结果产生很大的影响。

以下脚本说明了这种区别：

var result = 3;

            

            

            

            result++;

            

            

            

            println(result); // result is now 4

            

            

            

            ++result;

            

            

            

            println(result); // result is now 5

            

            

            

            println(++result); // result is now 6

            

            

            

            println(result++); // this still prints 6!

            

            

            

            println(result); // but the result is now 7

相等和关系运算符

相等和关系运算符确定一个操作数是大于、小于、等于还是不等于另一个操作数。

以下脚本用于测试这些操作数：

def num1 = 1;

            

            

            

            def num2 = 2;

            

            

            

            

            

            

            

            println(num1 == num2); // prints false

            

            

            

            println(num1 != num2); // prints true

            

            

            

            println(num1 > num2);  // prints false

            

            

            

            println(num1 >= num2); // prints false

            

            

            

            println(num1 < num2);  // prints true

            

            

            

            println(num1 <= num2); // prints true

条件运算符

条件与 (and) 和条件或 (or) 运算符用于对两个布尔表达式执行条件运算。这些运算符会表现出“短路”行为，也就是说，仅在必要时才计算第二个操作数：例如，对于 and 运算，如果第一个表达式的结果为 false，将不计算第二个表达式。对于 or 运算，如果第一个表达式的结果为 true，将不计算第二个表达式。

以下脚本定义了 username 和 password 变量，然后输出各个条件的匹配项，从而说明了这些运算符的用法：

def username = "foo";

            

            

            

            def password = "bar";

            

            

            

            

            

            

            

            if ((username == "foo") and (password == "bar")) {

            

            

            

            println("Test 1: username AND password are correct");

            

            

            

            }

            

            

            

            

            

            

            

            if ((username == "") and (password == "bar")) {

            

            

            

            println("Test 2: username AND password is correct");

            

            

            

            }

            

            

            

            

            

            

            

            if ((username == "foo") or (password == "bar")) {

            

            

            

            println("Test 3: username OR password is correct");

            

            

            

            }

            

            

            

            

            

            

            

            if ((username == "") or (password == "bar")) {

            

            

            

            println("Test 4: username OR password is correct");

            

            

            

            }

输出为：

Test 1: username AND password are correct

            

            

            

            Test 3: username OR password is correct

            

            

            

            Test 4: username OR password is correct

类型比较运算符

instanceof 运算符将对象与指定的类型相比较。您可以使用该运算符来确定某个对象是否为特定类的实例：

def str1="Hello";

            

            

            

            println(str1 instanceof String);  // prints true

            

            

            

            

            

            

            

            def num = 1031;

            

            

            

            println(num instanceof integer); // prints true

在本教程的最后一课中深入了解类和继承后，您将发现该运算符非常有用。

asdtiang 2010-01-15 13:03 发表评论

JAVA FX语法学习-----序列

asdtiang — Fri, 15 Jan 2010 04:58:00 GMT

创建序列的一种方法是显式列出其各个项。每个项都用一个逗号进行分隔，列表用方括号 "[" 和 "]" 括起来。例如，下面的代码：

def weekDays = ["Mon","Tue","Wed","Thu","Fri"];

声明了一个序列并将其赋给 weekDays。我们在这个例子中使用了 def，因为在创建序列后我们不打算改变它的值。这里，编译器知道我们打算创建一个“字符串序列”，因为每个项都声明为 String 字面值。如果序列是使用 Integer 声明的（例如，def nums = [1,2,3];），编译器将知道我们打算创建“整数序列”。

您还可以显式指定序列的类型，方法是修改序列的声明，使其包含后跟 "[]" 的类型名称。

def weekDays: String[] = ["Mon","Tue","Wed","Thu","Fri"];

这会通知编译器 weekDays 将用来存放 String 序列（而不是单个 String）。

您还可以在序列中声明其他序列：

def days = [weekDays, ["Sat","Sun"]];

在这种情况下，编译器将自动平展开嵌套的序列以构成单个序列，这样上面的代码就等效于：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

还可以通过简化表示法来更方便地创建可构成等差数列的序列。要创建一个由数字 1 至 100 构成的序列，请使用以下代码：

def nums = [1..100];

使用谓词

您可以使用布尔表达式（又称为谓词）声明一个为现有序列的子集的新序列。例如，请考虑以下代码：

def nums = [1,2,3,4,5];

要创建第二个序列（基于此第一个序列中的项）但仅包含大于 2 的数字，请使用以下代码：

def numsGreaterThanTwo = nums[n | n > 2];

可以将上面的代码行用中文表示为：“从 nums 序列中选择项值大于 2 的所有项并将这些项赋给名为 numsGreaterThanTwo 的新序列。”以粗体突出显示的“项值大于 2”子句是谓词。

在这些代码中：

新创建的序列存储在 numsGreaterThanTwo 中。
代码 nums[n | n > 2]; 中标记为粗体的部分指定要从中复制项的原始序列。在我们的示例中，nums 是原始序列的名称。
这会选择 nums 中的项，并按顺序返回一个由使表达式为 true 的项构成的新序列。
"|" 字符用来在视觉上将变量 "n" 与代码的其余部分隔开：nums[n | n > 2];
代码 nums[n | n > 2]; 中标记为粗体的部分定义一个布尔表达式，该表达式指定将当前项复制到新序列中时需要满足的条件。

访问序列中的项

序列中的项是按数字索引（从 0 开始）进行访问的。要访问单个项，请键入序列名称，后跟该项的数字索引（用方括号括起来）：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            

            println(days[0]);

            println(days[1]);

            println(days[2]);

            println(days[3]);

            println(days[4]);

            println(days[5]);

            println(days[6]);

这会将以下内容输出到屏幕上：

您还可以使用后跟序列名称的 sizeof 运算符来确定序列的大小：

sizeof days

以下代码会将 "7" 输出到屏幕上：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            println(sizeof days);

在序列中插入项

insert 关键字可用于在序列中特定项的前面或后面插入一个项。

注：从技术上讲,序列是不可变的，即一经创建就永不更改。在修改序列（例如通过插入或删除项）时，会在后台创建一个新序列并重新指定序列变量，这会给人一种序列已被修改的印象。

让我们通过重新创建 days 序列来对此进行研究。请注意，我们现在用 var 来声明变量 days，因为我们会在创建原始序列后改变它的值：

var days = ["Mon"];

此时，该序列仅包含一个项 "Mon"。

我们可以使用 insert 和 into 关键字在该序列的末尾插入 "Tue"：

insert "Tue" into days;

类似地，我们也可以添加 "Fri"、"Sat" 和 "Sun"：

insert "Fri" into days;

            insert "Sat" into days;

            insert "Sun" into days;

该序列中现在包含："Mon"、"Tue"、"Fri"、"Sat" 和 "Sun"。

我们还可以使用 insert 和 before 关键字在给定索引处的项前面插入一个项。请记住，索引是从 0 开始的，因此，在当前的序列中，"Fri" 位于索引位置 2。因此，我们可以在 "Fri" 前面插入 "Thu"，如下所示：

insert "Thu" before days[2];

该序列中现在包含："Mon"、"Tue"、"Thu"、"Fri"、"Sat" 和 "Sun"。

要在 "Tue" 后面插入 "Wed"，我们可以使用 insert 和 after 关键字：

insert "Wed" after days[1];

该序列现在包含一周中的每一天："Mon"、"Tue"、"Wed"、"Thu"、"Fri"、"Sat" 和 "Sun"。

从序列中删除项

通过使用 delete 和 from 关键字可以轻松地从序列中删除项：

delete "Sun" from days;

该序列中现在包含："Mon"、"Tue"、"Wed"、"Thu"、"Fri" 和 "Sat"。

还可以删除位于特定索引位置的项。以下代码从该序列中删除 "Mon"（请记住，"Mon" 是第一个项，因此它的索引位置为 0）。

delete days[0];

要删除序列中的所有项，请使用后跟序列名称的 delete 关键字：

delete days;

请注意，delete 仅从序列中删除项，而不从脚本中删除 days 变量。您仍可以像以前那样访问 days 变量并向其中添加新项。

颠倒序列中项的次序

使用 reverse 运算符可以轻松地颠倒序列中项的次序：

var nums = [1..5];

            reverse nums; // returns [5, 4, 3, 2, 1]

比较序列

有时，您可能希望对序列进行比较，看它们是否相等。序列是按值来比较是否相等的：如果它们的长度相同而且各个项相等，则它们相等。

让我们创建两个具有相同内容的序列来对此进行测试：

def seq1 = [1,2,3,4,5];

            def seq2 = [1,2,3,4,5];

            println(seq1 == seq2);

表达式 seq1 == seq2 的值为 true，因为这两个序列具有相同数量的项，而且这两个序列中每个项的值都相等。因此，这些代码会将 "true" 输出到屏幕上。

通过更改其中一个序列中项的数量（而不更改另一个序列），这两个序列现在具有不同的长度：

def seq1 = [1,2,3,4,5];

            def seq2 = [1,2,3,4,5,6];

            println(seq1 == seq2);

由于第二个序列比第一个序列长，从而这两个序列不相等，因此该脚本的输出为 "false"。

我们还可以通过更改项的值来使两个序列不相等（即使这两个序列的长度仍相同）：

def seq1 = [1,2,3,4,5];

            def seq2 = [1,3,2,4,5];

            println(seq1 == seq2);

由于这两个序列不相等，因此这些代码将再次输出 "false"。

使用序列子集

序列子集提供对序列某些部分的访问。

seq[a..b]

此语法提供对位于索引 a 和索引 b之间（含 a 和 b）各个项的访问。以下脚本创建一个 weekend 序列，其中仅包含 "Sat" 和 "Sun" 项。

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

            def weekend = days[5..6];

seq[a..

使用 "<" 字符可以访问位于索引 a 和索引 b 之间（含 a，不含 b）的项。我们可以对 days 使用此方法来创建一个 weekdays 序列，其中包含项 "Mon" 至 "Fri"。

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
def weekdays = days[0..<5];

seq[a..]

通过省略第二个索引，可以访问从索引 a 到序列末尾处的所有项。为了与上一个示例保持一致，我们可以按如下方式创建 weekend 序列：

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
def weekend = days[5..];

seq[a..<]

最后，您可以使用不带第二个索引的 "<" 来访问从索引 a 到序列末尾处的所有项（不含最后一项）。

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
def days2 = days[0..<];

此版本会创建一个 days2 序列，其中包含项 "Mon" 至 "Sat"。

asdtiang 2010-01-15 12:58 发表评论

JAVA FX语法学习----基础

asdtiang — Fri, 15 Jan 2010 04:14:00 GMT
脚本变量是使用 var 或 def 关键字声明的。二者之间的区别在于：
    在脚本的整个生命周期内都可以为 var 变量赋予新值，
    而 def 变量在被首次赋予新值后将保持不变。
函数实例：

function add(argOne: Integer, argTwo: Integer) : Integer {

result = argOne + argTwo;//红色表示参数和返回类型

println("{argOne} + {argTwo} = {result}");

return result;

}

一个类的实例：

其实有了JAVA的基础，类的概念还是比较好理解的。只是写法上不同而已

public class Address {

public   var street;
public   var city;
public   var state;
public   var zip;
}

///在另一个类中的使用
def myAddress = Address {
     street: "1 Main Street";
     city: "Santa Clara";
     state: "CA";
     zip: "95050";
}
var address;

address=Address{
        street: "1 Main Street";
     city: "Santa Clara";
     state: "CA";
     zip: "95050";
        }

数据类型：JavaFX Script 编程语言支持字符串类型、数值类型、布尔 (true/false)

类型。还支持基于时间（持续时间）的类型，以及用于指示函数不返回任何值和指示缺少正常值的特殊类型

A:String

def name = 'Joe';
var s = "Hello {name}"; // s = 'Hello Joe'
def answer = true;
var s = "The answer is {if (answer) "Yes" else "No"}"; // s = 'The answer is Yes'
def one = "This example ";
def two = "joins two strings.";
def three = "{one}{two}";      // join string one and string two
println(three);

B：Number and Integer

def numOne : Number = 1.0;
def numTwo : Integer = 1;

这两种类型之间的区别是，Number 表示浮点数字，而 Integer

仅表示整数。只有当您确实需要浮点精度时才应使用 Number，否则应首选 Integer

注意：从 SDK 1.1 开始，该语言还包含与 Java 编程语言中的数值类型相一致的数值类型。因此，
数值类型的完整列表为：Byte、Short、Number、Integer、Long、Float、Double和 Character。
但以上给出的建议仍是正确的：大多数程序员在其编写的脚本中只需要使用 Integer（或Number）。
如果您在学习该语言时具有 Java

编程语言背景并且需要完成一个必须使用其他数值类型的任务，那么请记住您的脚本现在可以使用这些附加类型。

D：其它
function printMe() :Void{ ///注意V是大写的
println("I don't return anything!");

Duration 类型表示固定的时间单元（毫秒、秒、分钟或小时）。
null 是一个特殊的值，用来指示缺少正常值。null 与零或空字符串不同，因此 null比较与零或空字符串比较不同。

asdtiang 2010-01-15 12:14 发表评论