亚洲欧洲国产经精品香蕉网,亚洲中文字幕无码爆乳,亚洲最大AV网站在线观看

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

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

bind 关键字将目标变量的��g��l�定表达式的值相兌��。绑定表辑ּ�可以是某个基本类型的��单倹{��对象、函数的�l�果或表辑ּ�的结果。以下几节分别提供每�U�绑定表辑ּ� 的示例�?/p>

在大多数实际的编�E�情况下�Q�需要通过数据�l�定使应用程序的囑�Ş用户界面 (Graphical User Interface, GUI) 与其底层数据同步。（GUI �~�程�?a >使用 JavaFX 构徏 GUI 应用�E�序的主题；下面我们��用一些非可视的示例来说明基本的底层结构。）

让我们先看一个简单的�C�Z��Q�下面的脚本��变�?x �l�定到变�?y�Q? 更改 x 的��|��然后输出 y 的倹{��由于这两个变量�l�定在一��P��因此 y ��g��自动更新为新倹{�?/p>

var x = 0;

def y = bind x;

x = 1;

println(y); // y now equals 1

x = 47;

println(y); // y now equals 47

��h��意，我们已将变量 y 声明�?def。这可防止�Q何代码直�? ��变量赋��|��管允许该变量的值因�l�定 (bind) 而更改）。在�l�定到对象时�Q�此�U�定仍适用�Q�请回顾�? 用对�?/a>中介�l�的 Address�Q�：

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

��h��意，更改 myStreet 的值实际上会导致创��Z��个新�?Address 对象�Q�然后将该对象重新赋�l?address 变量。�ؓ了跟�t�所做的更改�?em>�?/em>创徏新的 Address 对象�Q�请改�ؓ直接�l�定 (bind) 到该对象的实例变量：

def address = bind Address {

street: bind myStreet;

city: bind myCity;

state: bind myState;

zip: bind myZip;

};

如果要显式绑定到实例变量�Q�还可以省略�W�一�?bind�Q?code>Address 前面的那个）�Q?/p>

def address = Address {

street: bind myStreet;

city: bind myCity;

state: bind myState;

zip: bind myZip;

};

�l�定和函�?/strong>

前面的课�E�已讲授了函敎ͼ�但是您还必须了解�l�定函数�?em>非绑定函�?/em>之间的区别�?/p>
误��虑下面的函敎ͼ�该函数创建和�q�回一�?Point 对象�Q?/p>

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;

}

�q�就是所谓的�l�定函数�Q�因为它前面�?bound 关键字�?/p>

注意�Q?code>bound 关键字不能替�?bind 关键字；�q�两个关键字按如下所�C�方式结合��用�?

接下来，让我们添加一些代码来调用此函数�ƈ��试�l�定�Q?/p>

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

此脚本的输出如下所�C�：

3.0

10.0

20.0

让我们分析一下此脚本�Q�一�ơ分析一部分�Q��?/p>
代码�Q?/p>

var myX = 3.0;

var myY = 3.0;

def pt = bind makePoint(myX, myY);

println(pt.x);

��脚本变�?myX �?myY 初始化�ؓ 3.0�? �q�些值随后作为参��C��递给 makePoint 函数�Q�该函数会创建�ƈ�q�回一个新�?Point 对象�?code>bind 关键字（位于 makePoint 调用前面�Q�将新创建的 Point 对象 (pt) �l�定�?makePoint 函数的结果�?/p>
接下来，代码�Q?/p>

myX = 10.0;

println(pt.x);

��?myX 的值更改�ؓ 10.0 �q�输�?pt.x 的倹{��输��? pt.x 现在也�ؓ 10.0�?/p>
最后，代码�Q?/p>

scale = 2.0;

println(pt.x);

更改 scale 的值�ƈ再次输出 pt.x 的倹{�?code>pt.x 的值现在�ؓ 20.0。但是，如果我们从该函数中删�?bound 关键字（从而��其成为非�l�定函数�Q�，则输出应为：

3.0

10.0

10.0

�q�是因�ؓ�Q�非�l�定函数只是在其某个参数发生变化时才被重新调用。由�?scale 不是函数的参敎ͼ�因此更改它的值将不会��D��另一个函数调用�?/p>
对序列进行绑�?/strong>

您还可以��?bind �?for 表达式结合��用。�ؓ了对此进行研�IӞ��让我们首先定义两个序列�ƈ输出�q�两个序列中各个��的��|��

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�Q��?code>seq2 也包含十个项�Q�这些项本来会与 seq1 ��h��相同的��|��但是我们已经对其中的每个��w��应用了表辑ּ� item*2�Q? 因此它们的值将加倍�?/p>
因此�Q�输��Zؓ�Q?/p>

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 关键字前面来�l�定�q�两个序列�?/p>

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

问题现在变成�Q?#8220;如果 seq1 发生了某些变化，那么�?seq2 中的所�?/em>��w��受到影响�q�是部分��受到媄响？”我们可以通过以下�Ҏ��来对此进行测试：��一个项�Q��?11�Q�插�? seq1 的末��֤��Q�然后输��两个序列的��|��看有什么变化：

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

}

输出�Q?/p>

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

输出表明�Q�将 11 插入 seq1 的末��֤�不会影响 seq2 中的�?10 个项�Q�新��会自动��d��? seq2 的末��֤��Q�其��gؓ 22�?/p>
替换触发�?/strong>

替换触发�?/em>是附加到变量的�Q意代码块�Q�一旦变量的值发生变化，它们��׃��执行。以下示例显�C�Z��基本语法�Q? 它定义一�? password 变量�q�向光��加一个替换触发器�Q�当密码发生变化�Ӟ��该触发器会输��Z��则消息来报告此变量的新��|��

var password = "foo" on replace oldValue {

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

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

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

};

password = "bar";

此示例的输出如下所�C�：

ALERT! Password has changed!

Old Value:

New Value: foo

ALERT! Password has changed!

Old Value: foo

New Value: bar

此示例中的触发器引发两次�Q�当 password 初始化�ؓ "foo" 时引发一�ơ，当其值变�?"bar" 时又引发一�ơ。请注意�Q?code>oldValue 变量存储在调用触发器之前变量的倹{��您可以��?oldValue 变量命名��Z�Q何所需的名�U�ͼ�我们是由于该名称��h��描述性才恰好使用它�?/p>

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

asdtiang — Fri, 15 Jan 2010 06:23:00 GMT
表达�?/em>是可以生成某个结果值的代码�D�，可以�l�合使用表达式来生成“更大�?#8221;表达式。JavaFX Script �~�程语言是表辑ּ�语言�Q�这意味着一切（包括循环、条件甚臛_��Q�都是表辑ּ�。在某些情况下（�?while 表达式）�Q�表辑ּ��h�� Void �c�d��Q�这意味着它们不返回结果�?br />
块表辑ּ�

块表辑ּ��׃��p�d��声明或表辑ּ��l�成�Q�它们括在花括号中�ƈ用分可��行分隔。块表达式的值是最后一个表辑ּ� 的倹{��如果块表达式中不包含表辑ּ��Q�则其类型�ؓ Void。请注意�Q?code>var �?def 是表辑ּ��?/p>
下面的块表达式对几个数字�q�行相加�q�将�l�果存储在一个名�?total 的变量中�Q?/p>

var nums = [5, 7, 3, 9];
var total = {
var sum = 0;
for (a in nums) { sum += a };
sum;
}
println("Total is {total}.");

�q�行此脚本将生成以下输出�Q?/p>

Total is 24.

�W�一�?(var nums = [5, 7, 3, 9];) 声明一个整数序列�?/p>
�W�二行声明一个名�?total 的变量，该变量将用来存放�q�些整数的和�?/p>
随后的块表达式由左花括号和右花括号之间的所有内�Ҏ��成：

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

在该块内部，�W�一行代码声明一个名�?sum 的变量，该变量将用来存放此序列中各个数字之和。第二行�Q�一�?for 表达�?/a>�Q�遍历该序列�Q�将每个数字�?sum 相加。最后一行设�|�该块表辑ּ�的返回��|��在本例中�?24�Q��?/p>
if 表达�?/strong>

使用 if 表达式后�Q?em>仅当特定条�g为真时才执行某些代码块，从而对�E�序��? �q�行定向�?/p>
例如�Q�以下脚本基于年龄来讄��h�?2 岁到 65 岁的人支付正�怭h 10 ��元。老�h和儿童支�?5 ��元�Q? 岁以下的儿童免费�?/p>

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�Q�该脚本��生成以下输出：

Age: 8 Ticket Price: 5 dollars.

该示例的�E�序��如下所�C�：

if (age < 5 ) {
ticketPrice = 0;
} else if (age < 12 or age > 65) {
ticketPrice = 5;
} else {
ticketPrice = 10;
}

如果 age ��于 5�Q�则��h��设�|��ؓ 0�?/p>
�E�序随后��蟩�q�其余条件测试�ƈ输出�l�果�?/p>
如果 age 不小�?5�Q�程序将�l�箋执行下一个条件测试（由后跟另一�?if 表达式的 else 关键字来指示�Q�：

if (age < 5 ) {
ticketPrice = 0;
} else if (age < 12 or age > 65) {
ticketPrice = 5;
} else {
ticketPrice = 10;
}

如果人的�q�龄�?5 �?12 岁之间或者大�?65 岁，该程序会��票仯��|��ؓ 5 ��元�?/p>
如果人的�q�龄�?12 �?65 岁之��_��E�序会流��x��后一个代码块�Q�用 else 关键字进行标讎ͼ��Q?/p>

if (age < 5 ) {
ticketPrice = 0;
} else if (age < 12 or age > 65) {
ticketPrice = 5;
} else {
ticketPrice = 10;
}

只有当前面的所有条件均不满��x��Q�才会执行此块。它会针�?12 �?65 岁之间的人将��h讄��?10 ��元�?/p>

注：可以��上面的代码�~�减成一个非常简�z�的条�g表达式：

ticketPrice = if (age < 5) 0 else if (age < 12 or age > 65) 5 else 10;

�q�是一个需要掌握的有用�Ҏ��Q�在本教�E�的�? 面部分中�q�会使用它�?

范围表达�?/strong>

“序列”一课讲授了一�U�用来声明�Ş成等差数列的数字序列的简化表�C�法�?/p>

var num = [0..5];

从技术上�Ԍ��[0..5] 是一�?em>范围表达�?/em>。默认情况下�Q�相��d��g��间的�? 隔�ؓ 1�Q�但是您可以使用 step 关键字来指定一个不同的间隔。例如，定义一个由 1 �?10 之间的奇数构成的序列�Q?/p>

var nums = [1..10 step 2];
println(nums);

此脚本的输出如下所�C�：

[ 1, 3, 5, 7, 9 ]

要创�?em>降序范围�Q�请��保�W�二个值小于第一个��|��q�指定一个负�?step ��|��

var nums = [10..1 step -1];
println(nums);

输出为：

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

如果您在创徏降序范围时没有提�?em>负的 step ��|��则会生成一个空序列�?/p>
以下代码�Q?/p>

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 ��|��也会生成一个空序列�?/p>
for 表达�?/strong>

另一个与序列有关的表辑ּ��?for 表达式�?code>for 表达式�ؓ遍历序列中的各个��Ҏ��供了一�U�方便的机制�?/p>
以下代码提供了一个示例：

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

for (day in days) {
println(day);
}

此脚本的输出如下所�C�：

Mon
Tue
Wed
Thu
Fri
Sat
Sun

让我们将该示例分成几个部分�?code>for 表达式以 "for" 关键字开��_��

for (day in days) {
println(day);
}

days 变量是要�?for 表达式处理的输入序列�? 名称�Q?/p>

for (day in days) {
println(day);
}

�?for 表达式遍历该序列�Ӟ��day 变量用来存放当前��：

for (day in days) {
println(day);
}

��h��意，不需要在脚本中的其他位置声明 day 变量卛_��其用在 for 表达式中。此外，在完成整个��@环之后，��无法访�?day。程序员通常会赋予��时变量（如该变量�Q�非常短的名�U�ͼ�或由一�? 字母构成的名�U�ͼ��?/p>
在上例中�Q�未昄�� for �q�回��|��?for 也是一个返回序列的表达式。以下代码显�C�Z��两个使用 for 表达式从另一个序列创建序列的�C�Z��Q?/p>

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

��h��意，toUpperCase 函数�?String 对象提供。您可以通过查阅 API 文档来查看完整的可用函数列表�?/p>
while 表达�?/strong>

另一个��@环结构是 while 表达式。与作用于序列中��的 for 表达式不同，while 表达式会一直��@环，直到�l�定的表辑ּ��?false 为止。尽��?while 在语法上是表辑ּ��Q�但是它的类型�ؓ Void�Q�不�q�回倹{�?/p>
下面提供了一个示例：

var count = 0;
while (count < 10) {
println("count == {count}");
count++;
}

此脚本的输出如下所�C�：

count == 0
count == 1
count == 2
count == 3
count == 4
count == 5
count == 6
count == 7
count == 8
count == 9

�W�一行声明一个名�?count 的变量�ƈ��其初始化�ؓ 0�Q?/p>

var count = 0;
while (count < 10) {
println("count == {count}");
count += 1;
}

�W�二行以 while 表达式开头。此表达式创��Z��一个��@环（在左花括号和双��括号之间�Q�，该��@环会一直进行，直到 count < 10 的��gؓ false 为止�Q?/p>

var count = 0;
while (count < 10) {
println("count == {count}");
count += 1;
}

While 表达式的��M��会输�?count 的当前��|��然后��?count 的值加 1�Q?/p>

var count = 0;
while (count < 10) {
println("count == {count}");
count += 1;
}

�?count �{�于 10 �Ӟ��循环退出。要创徏一个无限��@环，请将 true 关键字放在左��括号和叛_��括号之间�Q�如 while(true){} 中所�C��?/p>
break �?continue 表达�?/strong>

break �?continue 表达式与循环表达式有兟뀂这两个表达式会影响循环�q�代�Q?code>break 完全攑ּ�循环�Q��?continue 仅放弃当前�P代�?/p>
��管 break �?continue 在语法上是表辑ּ��Q�但它们的类型�ؓ Void�Q�不�q�回倹{�?/p>
�C�Z��Q?/p>

for (i in [0..10]) {
if (i > 5) {
break;
}

if (i mod 2 == 0) {
continue;
}

println(i);
}

输出�Q?/p>

1
3
5

如果没有 if 表达式，该程序将只是输出 0 �?10 之间的数字�?/p>
如果只有�W�一�?if 表达式，�E�序��在 i 的值大�?5 �?em>�? �?/em>循环�Q?/p>

if (i > 5) {
break;
}

因此�Q�程序将仅输�?1 �?5 之间的数字�?/p>
通过��d��W�二�?if 表达式，�E�序��仅攑ּ�循环的当前�P代�?em>�l�箋执行下一个�P代：

if (i mod 2 == 0) {
continue;
}

在这�U�情况下�Q�只有当 i 为偶敎ͼ��?i 能被 2 整除�Q�没有余敎ͼ�时才执行 continue。出现这�U�情冉|��Q�将永远不会调用 println()�Q? 因此输出中将不包含该数字�?/p>
throw、try、catch �?finally 表达�?/strong>

在实际的应用�E�序中，正常的脚本执行流有时会被某个事�g中止。例如，如果脚本从某个文件中��d��输入�Q�但是找不到该文�Ӟ��? 脚本��无法��l�。我们将�q�种情况�U�Cؓ“异常”�?/p>

注意�Q�异常是对象。它们的�c�d��通常以它们所表示的情况命名（例如�Q?code>FileNotFoundException 表示找不到文件的情况�Q�。但是，定义一�l�特定于卛_��l�出的示例的异常不在本节的讨��围之内。因此，我们��用一个通用�?Exception 对象�Q�从 Java �~�程语言借用而来�Q�来说明 throw�?code>try�?code>catch �? finally 表达式�?

以下脚本定义�Q�和调用�Q�一个会抛出异常的函敎ͼ�

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.");
}
}

按原栯��行此脚本�Q�将 somethingWeird 讄��?false�Q? ��输��Z��下消息：

We made it through the function.
The script is now executing as expected...

但是�Q�如果将该变量更改�ؓ true�Q�则会抛出异常。在�q�行�Ӟ��该脚本将崩溃�q�显�C�Z��下消息：

Exception in thread "main" java.lang.Exception: Something weird just happened!
at exceptions.foo(exceptions.fx:10)
at exceptions.javafx$run$(exceptions.fx:3)

��Z��防止崩溃�Q�我们将需要��?try/catch 表达式来包装 foo() 调用。顾名思义�Q�这些表辑ּ���试执行某些代码�Q�但会在出现问题�?em>捕捉异常�Q?/p>

try {
foo();
} catch (e: Exception) {
println("{e.getMessage()} (but we caught it)");
}

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

Something weird just happened! (but we caught it)
The script is now executing as expected...

�q�有一�?finally 块（它在技术上不是表达式）�Q�无论是否抛��Z��异常�Q�该块始�l�在 try 表达式退��Z��后的某个旉��执行�?code>finally 块用来执行无�?try ��M��是成功还是抛出异帔R��需要执行的清除操作�?/p>

try {
foo();
} catch (e: Exception) {
println("{e.getMessage()} (but we caught it)");
} finally {
println("We are now in the finally expression...");
}

�E�序输出现在为：

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 发表评论

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

赋��D��符

赋��D��符 "=" 是您��遇到的最常用的运��符。��用该�q�算�W�可以将其右侧的��D��l�其左侧的操作数�Q?/p>

result = num1 + num2;

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

��术�q�算�W?/strong>

使用��术�q�算�W?/em>可以执行加、减、乘和除�q�算�?code>mod �q�算�W�用一个操作数除以另一个操作数�q�将余数作�ؓ�l�果�q�回�?/p>

+ �Q�加�q�算�W�）

- �Q�减�q�算�W�）

* �Q�乘�q�算�W�）

/ �Q�除�q�算�W�）

mod �Q�求余运��符�Q?/pre>

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

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

您还可以�l�合使用��术�q�算�W�与赋��D��符来创�?em>复合赋�?/em>。例如，result += 1; �?result = result+1; 都会��?result 的值加 1�?/p>

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

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

一元运��符

大多数运��符都需要两个操作数�Q��?em>一元运��符仅��用一个操作数来执行诸如按一递增/递减某个倹{��对某个数字求反或对布尔值求反之�cȝ��操作�?/p>

- 一元减�q�算�W�；�Ҏ��个数字求�?br />

++ 递增�q�算�W�；�?1 递增某个�?br />

-- 递减�q�算�W�；�?1 递减某个�?br />

not 逻辑求补�q�算�W�；对布��值求�?/pre>

以下脚本用于��试一元运��符�Q?/p>

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

递增/递减�q�算�W�可以在操作��C��前（前缀�Q�或之后�Q�后�~��Q�应用。代�?result++; �? ++result; 都将��D�� result 的值加 1。二者之间的唯一区别��是前缀版本 (++result) 得到的是递增后的��|��而后�~�版本 (result++) 得到的是原始倹{��（您可以通过以下�Ҏ��来记忆：++result 先执行递增再获得��|��?result++ 先获得值再执行递增。）如果您只是执行简单的递增/递减�Q�则选择哪个版本都一栗��但是，如果您将该运��符作�ؓ较大表达式的一部分�q�行使用�Q�则选择不同的版本会对结果��生很大的影响�?/p>
以下脚本说明了这�U�区别：

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

相等和关�p�运��符

相等和关�p�运��符��定一个操作数是大于、小于、等于还是不�{�于另一个操作数�?/p>

== �{�于

!= 不等�?br />

> 大于

>= 大于或等�?br />

< ��于

<= ��于或等�?/pre>

以下脚本用于��试�q�些操作敎ͼ�

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

条�g�q�算�W?/strong>

条�g�?(and) �?em>条�g�?(or) �q�算�W�用于对两个布尔表达式执行条件运��。这些运��符会表现出“短�\”行�ؓ�Q�也��是��_��仅在必要时才计算�W�二个操作数�Q�例如，对于 and �q�算�Q�如果第一个表辑ּ�的结果�ؓ false�Q�将不计��第二个表达式。对�?or �q�算�Q�如果第一个表辑ּ�的结果�ؓ true�Q? ��不计算�W�二个表辑ּ��?/p>

and

or

以下脚本定义�?username �?password 变量�Q�然后输出各个条件的匚w��，从而说明了�q�些�q�算�W�的用法�Q?/p>

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

�c�d��比较�q�算�W?/strong>

instanceof �q�算�W�将对象与指定的�c�d��相比较。您可以使用该运��符来确定某个对象是否�ؓ特定�cȝ��实例�Q?/p>

def str1="Hello";

println(str1 instanceof String); // prints true

def num = 1031;

println(num instanceof integer); // prints true

在本教程的最后一课中深入了解�c�d��l�承后，您将发现该运��符非常有用�?/p>

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

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

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

创徏序列的一�U�方法是昑ּ�列出其各个项。每个项都用一个逗号�q�行分隔�Q�列表用�Ҏ��?"[" �?"]" 括�v来。例如，下面的代码：

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

声明了一个序列�ƈ��其赋给 weekDays。我们在�q�个例子中��用了 def�Q? 因�ؓ在创建序列后我们不打��改变它的倹{��这里，�~�译器知道我们打��创��Z��?#8220;字符串序�?#8221;�Q�因为每个项都声明�ؓ String 字面倹{��如果序列是使用 Integer 声明的（例如�Q?code>def nums = [1,2,3];�Q�， �~�译器将知道我们打算创徏“整数序列”�?/p>
您还可以昑ּ�指定序列的类型，�Ҏ��是修改序列的声明�Q��其包含后�?"[]" 的类型名�U��?/p>

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

�q�会通知�~�译�?weekDays ��用来存�?String 序列�Q�而不是单�? String�Q��?/p>
您还可以在序列中声明其他序列�Q?/p>

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

在这�U�情况下�Q�编译器��自动��^展开嵌套的序列以构成单个序列�Q�这样上面的代码��q��效于�Q?/p>

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

�q�可以通过��化表�C�法来更方便地创建可构成�{�差数列的序列。要创徏一个由数字 1 �?100 构成的序列，请��用以下代码：

def nums = [1..100];

使用谓词

您可以��用布��表辑ּ��Q�又�U�Cؓ谓词�Q�声明一个�ؓ现有序列的子集的新序列。例如，误��虑以下代码�Q?/p>

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

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

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

可以��上面的代码行用中文表示为：“�?nums 序列中选择��值大�?2 的所有项�q�将�q�些��赋�l�名�?numsGreaterThanTwo 的新序列�?#8221;以粗体突出显�C�的“��值大�? 2”子句是谓词�?/p>
在这些代码中�Q?/p>

新创建的序列存储�?numsGreaterThanTwo 中�?/li>
代码 nums[n | n > 2]; 中标��Cؓ�_�体的部分指定要从中复制��的原始序列。在我们的示例中�Q?code>nums 是原始序列的名称�?/li>
�q�会选择 nums 中的��，�q�按��序�q�回一个由使表辑ּ��?true 的项构成的新序列�?/li>
"|" 字符用来在视觉上��变�?"n" 与代码的其余部分隔开�Q?code>nums[n | n > 2];

代码 nums[n | n > 2]; 中标��Cؓ�_�体的部分定义一个布��?em>表达�?/em>�Q�该表达式指定将当前��复制到新序列中旉��要满��的条�g�?/li>

讉K��序列中的��?/strong>

序列中的��Ҏ��按数字烦引（�?0 开始）�q�行讉K��的。要讉K��单个��，请键入序列名�U�ͼ�后跟该项的数字烦引（用方括号括�v来）�Q?/p>

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]);

�q�会��以下内容输出到屏幕上：

Mon
Tue
Wed
Thu
Fri
Sat
Sun

您还可以使用后跟序列名称�?sizeof �q�算�W�来��定序列的大��：

sizeof days

以下代码会将 "7" 输出到屏�q�上�Q?/p>

def days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
println(sizeof days);

在序列中插入��?/strong>

insert 关键字可用于在序列中特定��的前面�?em>后面�? �?/em>一个项�?/p>

注：从技术上�?序列�?em>不可变的�Q�即一�l�创建就�怸�更改。在修改序列�Q�例如通过插入或删除项�Q�时�Q�会在后台创 ��Z��个新序列�q��新指定序列变量，�q�会�l��h一�U�序列已被修改的印象�?

让我们通过重新创徏 days 序列来对此进行研�I�。请注意�Q�我们现在用 var 来声明变�? days�Q�因为我们会在创建原始序列后改变它的��|��

var days = ["Mon"];

此时�Q�该序列仅包含一个项 "Mon"�?/p>
我们可以使用 insert �?into 关键字在该序列的末尾插入 "Tue"�Q?/p>

insert "Tue" into days;

�c�M��圎ͼ�我们也可以添�?"Fri"�?code>"Sat" �?"Sun"�Q?/p>

insert "Fri" into days;
insert "Sat" into days;
insert "Sun" into days;

该序列中现在包含�Q?code>"Mon"�?code>"Tue"�?code>"Fri"�?code>"Sat" �?"Sun"�?/p>
我们�q�可以��?insert �?before 关键字在�l�定索引处的��前面插入一个项。请��C��Q�烦引是�? 0 开始的�Q�因此，在当前的序列中，"Fri" 位于索引位置 2。因此，我们可以�?"Fri" 前面插入 "Thu"�Q�如下所�C�：

insert "Thu" before days[2];

该序列中现在包含�Q?code>"Mon"�?code>"Tue"�?code>"Thu"�?code>"Fri"�?code>"Sat" �?"Sun"�?/p>
要在 "Tue" 后面插入 "Wed"�Q�我们可以��?insert �? after 关键字：

insert "Wed" after days[1];

该序列现在包含一周中的每一天："Mon"�?code>"Tue"�?code>"Wed"�?code>"Thu"�?code>"Fri"�?code>"Sat" �?"Sun"�?/p>
从序列中删除��?/strong>

通过使用 delete �?from 关键字可以轻村֜�从序列中删除��：

delete "Sun" from days;

该序列中现在包含�Q?code>"Mon"�?code>"Tue"�?code>"Wed"�?code>"Thu"�?code>"Fri" �?"Sat"�?/p>
�q�可以删除位于特定烦引位�|�的��V��以下代码从该序列中删除 "Mon"�Q�请��C��Q?code>"Mon" 是第一个项�Q�因此它的烦引位�|��ؓ 0�Q��?/p>

delete days[0];

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

delete days;

��h��意，delete 仅从序列中删除项�Q�而不从脚本中删除 days 变量。您仍可以像以前那样讉K�� days 变量�q�向其中��d��新项�?/p>
颠倒序列中��的�ơ序

使用 reverse �q�算�W�可以轻村֜�颠倒序列中��的�ơ序�Q?/p>

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

比较序列

有时�Q�您可能希望对序列进行比较，看它们是否相�{�。序列是按值来比较是否相等的：如果它们的长度相同而且各个��相�{�，则它们相�{��?/p>
让我们创��Z��个具有相同内容的序列来对此进行测试：

def seq1 = [1,2,3,4,5];
def seq2 = [1,2,3,4,5];
println(seq1 == seq2);

表达�?seq1 == seq2 的��gؓ true�Q�因��? 个序列具有相同数量的��，而且�q�两个序列中每个��的值都相等。因此，�q�些代码会将 "true" 输出到屏�q�上�?/p>
通过更改其中一个序列中��的数量�Q�而不更改另一个序列）�Q�这两个序列现在��h��不同的长度：

def seq1 = [1,2,3,4,5];
def seq2 = [1,2,3,4,5,6];
println(seq1 == seq2);

�׃��W�二个序列比�W�一个序列长�Q�从而这两个序列不相�{�，因此该脚本的输出�?"false"�?/p>
我们�q�可以通过更改��的值来使两个序列不相等�Q�即使这两个序列的长度仍相同�Q�：

def seq1 = [1,2,3,4,5];
def seq2 = [1,3,2,4,5];
println(seq1 == seq2);

�׃��q�两个序列不相等�Q�因此这些代码将再次输出 "false"�?/p>
使用序列子集

序列子集提供对序列某些部分的讉K��?/p>
seq[a..b]

此语法提供对位于索引 a 和烦�?b之间�Q�含 a �? b�Q�各个项的访问。以下脚本创��Z��? weekend 序列�Q�其中仅包含 "Sat" �?"Sun" ��V�?/p>

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

seq[a..

使用 "<" 字符可以讉K��位于索引 a 和烦�?b 之间�Q�含 a�Q?em>不含 b�Q�的��V��我们可以对 days 使用此方法来创徏一�?weekdays 序列�Q�其中包含项 "Mon" �?"Fri"�?/p>

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

seq[a..]

通过省略�W�二个烦引，可以讉K��从烦�?a 到序列末��֤�的所有项。�ؓ了与上一个示例保持一��_��我们可以按如下方式创�? weekend 序列�Q?/p>

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

seq[a..<]

最后，您可以��用不带第二个索引�?"<" 来访问从索引 a 到序列末��֤�的所有项�Q?em>�? �?/em>最后一��）�?/p>

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

此版本会创徏一�?days2 序列�Q�其中包含项 "Mon" �? "Sat"�?/p>

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

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

asdtiang — Fri, 15 Jan 2010 04:14:00 GMT
脚本变量是��?var �?def 关键字声明的。二者之间的区别在于�Q?br />     在脚本的整个生命周期内都可以�?var 变量赋予新��|��
    �?def 变量在被首次赋予新值后��保持不变�?br /> 函数实例�Q?br />
function add(argOne: Integer, argTwo: Integer) : Integer {

result = argOne + argTwo;//�U�色表示参数和返回类�?/span>

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

return result;

}

一个类的实例：

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

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";
        }

数据�c�d��Q�JavaFX Script �~�程语言支持字符串类型、数值类型、布��? (true/false)

�c�d��。还支持��Z��旉��Q�持�l�时��_��的类型，以及用于指示函数不返回�Q何值和指示�~�少正常值的�Ҏ��c�d��

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�Q�Number and Integer

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

�q�两�U�类型之间的区别是，Number 表示��点数字�Q��?Integer

仅表�C�整数。只有当您确实需要��Q点精度时才应使用 Number�Q�否则应首�?Integer

注意�Q�从 SDK 1.1 开始，该语�a��q�包含与 Java �~�程语言中的数值类型相一致的数值类型。因此，
数值类型的完整列表为：Byte�?code>Short�?code>Number�?code>Integer�?code>Long�?code>Float�?code>Double�?Character�?br /> 但以上给出的��仍是正确的：大多数程序员在其�~�写的脚本中只需要��? Integer�Q�或Number�Q��?br /> 如果您在学习该语�a�时具�?Java

�~�程语言背景�q�且需要完成一个必��M��用其他数值类型的��d��Q�那么请��C��您的脚本现在可以使用�q�些附加�c�d��?

D�Q�其�?br /> function printMe() :Void{ ///注意V是大写的
println("I don't return anything!");

Duration �c�d��表示固定的时间单元（毫秒、秒、分钟或��时�Q��?br /> null 是一个特�D�的��|��用来指示�~�少正常倹{��null 与零或空字符串不同，因此 null比较与零或空字符串比较不同�?br />

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