JavaFX

---

Ostatnio wpadła mi w ręce książka JavaFx in Action, wiec czytając postaram się również troszku opowiedzieć o tym. Książka jest napisana dość lekkim jeżykiem, wszystko jest tłumaczone dokładnie i powoli więc naprawdę polecam ja osobom chcącym wzbogacić swoje projekty.

Wstęp do języka, czyli co i jak od podstaw

W javafx mamy do czynienia tylko i wyłącznie z obiektami, wszystko jest tu obiektem, nasze zmienne które będziemy definiować są nimi również, Javafx nie posiada zmiennych typu prostego. Zacznijmy może od tego jak wygląda komentarz w javafx, tu w sumie nie trzeba się za bardzo niczym martwić i nic nowego nie wprowadzono:

1. // to jest komentarz 1 liniowy  
2.   
3. /* 
4.  * to komentarz wieloliniowy 
5.  * 
6.  */  
7.   
8. /** 
9.  * nio i komentarz dla javafxdoc 
10.  * adnotacje są takie same jak w Javie np. 
11.  * @autor adas 
12.  */  

// to jest komentarz 1 liniowy

/*
 * to komentarz wieloliniowy
 *
 */

/**
 * nio i komentarz dla javafxdoc
 * adnotacje są takie same jak w Javie np.
 * @autor adas
 */

wspomnę jeszcze ze javafx nie posiada konwencji sytax dla zmiennych prymitywnych, czyli spokojnie możemy sobie nazwać nasza zmienna var int lub tez def int.

Typ zmiennej	Znaczenie	w Javie
Boolean	flaga true lub false	java.lang.Boolean
Byte	z bitem znaku 8-bitowa liczba całkowitą	java.lang.Byte
Character	bez bitu znaku 16-bitowy Unicode	java.lang.Character
Double	z bitem znaku 64-bitowa liczba zmiennoprzecinkowa	java.lang.Double
Duration	Interwał czasowy	Nie ma
Float	z bitem znaku 32-bitowa liczba zmiennoprzecinkowa	java.lang.Float
Integer	z bitem znaku 32-bitowa liczba całkowitą	java.lang.Integer
Long	z bitem znaku 64-bitowa liczba całkowitą	java.lang.Long
Number	z bitem znaku 32-bitowa liczba zmiennoprzecinkowa	java.lang.Float
Short	z bitem znaku 16-bitowa liczba całkowitą	java.lang.Short
String	ciąg znaków Unicode	java.lang.String

1. var valBool:Boolean = true;  
2. var valByte:Byte = -123;  
3. var valChar:Character = 65;  
4. var valDouble:Double = 1.23456789;  
5. var valFloat:Float = 1.23456789;  
6. var valInt:Integer = 8;  
7. var valLong:Long = 1234567890;  
8. var valNum:Number = 1.2345;  
9. var valShort:Short = 1234;  
10. var valStr:String = " nonus25 ";  
11. println("Boolean: {valBool}, Byte: {valByte}, Character: {valChar}, Double: {valDouble}, Float: {valFloat}, ");  
12. println(" Integer: {valInt}, Long: {valLong}, Number: {valNum}, Short: {valShort}, String: {valStr}");  
13. var hexInt:Integer = 0x20; //szesnastkowy - 32  
14. var octInt:Integer = 040; //ósemkowy - 32  
15. var eNum:Double = 1.234E-56; //podniesienie 10 do potęgi -56  
16. println("hex: {hexInt}, oct: {octInt}, e: {eNum}");  
17. // przeniesienie lini, podając argument dla metody println()  
18. // przypomnę ze w Javie wyglądało to tak "coś tam"+  
19. // +" znowu coś tam"  
20. println("tutaj do przeniesienia nie używamy znaku + "  
21. "po prostu zaczynamy nowy cudzysłów i piszemy dalej ....... ;)");  
22. var varS = "+ nie działa, muszę użyć \{\}";  
23. java.lang.System.out.println("i tak używam nową funkcje println \n {varS}");  

var valBool:Boolean = true;
var valByte:Byte = -123;
var valChar:Character = 65;
var valDouble:Double = 1.23456789;
var valFloat:Float = 1.23456789;
var valInt:Integer = 8;
var valLong:Long = 1234567890;
var valNum:Number = 1.2345;
var valShort:Short = 1234;
var valStr:String = " nonus25 ";
println("Boolean: {valBool}, Byte: {valByte}, Character: {valChar}, Double: {valDouble}, Float: {valFloat}, ");
println(" Integer: {valInt}, Long: {valLong}, Number: {valNum}, Short: {valShort}, String: {valStr}");
var hexInt:Integer = 0x20; //szesnastkowy - 32
var octInt:Integer = 040; //ósemkowy - 32
var eNum:Double = 1.234E-56; //podniesienie 10 do potęgi -56
println("hex: {hexInt}, oct: {octInt}, e: {eNum}");
// przeniesienie lini, podając argument dla metody println()
// przypomnę ze w Javie wyglądało to tak "coś tam"+
// +" znowu coś tam"
println("tutaj do przeniesienia nie używamy znaku + "
"po prostu zaczynamy nowy cudzysłów i piszemy dalej ....... ;)");
var varS = "+ nie działa, muszę użyć \{\}";
java.lang.System.out.println("i tak używam nową funkcje println \n {varS}");

kod ten wpisujemy gdzie nam się podoba nie ma to znaczenia, gdy używamy NetBeansa przy tworzeniu aplikacji dostaniemy od razu wygenerowany kawałek skryptu, więc dobrze jest usunąć lub też wy komentować cały kawałek bloku Stage{}. Wyniki z powyżej zmieszczonego kodu wyglądają następująco:

Boolean: true, Byte: -123, Character: A, Double: 1.23456789, Float: 1.2345679, 
Integer: 8, Long: 1234567890, Number: 1.2345, Short: 1234, String:  nonus25 
hex: 32, oct: 32, e: 1.234E-56
tutaj do przeniesienia nie używamy znaku + po prostu zaczynamy nowy cudzysłów i piszemy dalej ....... ;)
i tak używam nowa funkcje println 
 + nie działa, muszę użyć {}

teraz możemy pokazać ze definiowanie zmiennej nie wymusza na nas jej inicjalizacji zostaną nadane im automatycznie wartości deflault'towe:

1. var Bool:Boolean;  
2. var Int:Integer;  
3. var Num:Number;  
4. var Str:String;  
5. println("Wartości domyślne:\n"  
6. "Boolean: {Bool}, Integer: {Int}\n"  
7. "Number: {Num}, String: {Str}");  

var Bool:Boolean;
var Int:Integer;
var Num:Number;
var Str:String;
println("Wartości domyślne:\n"
"Boolean: {Bool}, Integer: {Int}\n"
"Number: {Num}, String: {Str}");

wyniki jakie dostaniemy:

Wartości domyślne:
Boolean: false, Integer: 0
Number: 0.0, String:

Jak widać wszystkim wartością zostały od razu nadane wartości domyślne, ale spójrzmy na String'a nie dał nam wyjątku NullPointer i nawet nie wyświetlił informacji null jak miało to miejsce w Javie. Bawiąc się dalej zmiennymi może, ale nie musi ;) przyjść nam do głowy taka sytuacja co się stanie jeśli nie podamy mu klasy do jakiej należy zmienna, no własnie co wtedy, mianowicie JavaFX użyje typu wnioskowania (ang. type inference):

1. println("Wnioskowanie:");  
2. var infBool = true;  
3. var infFlt = 1.0;  
4. var infInt = 1;  
5. var infStr = "chmielua@gmail.com";  
6. var varSome;  
7. println("infBool: {infBool},"  
8. "infFlt: {infFlt}\ninfInt: {infInt}, infStr: {infStr}");  
9. println("wynik dla zmiennej varSome: {varSome}");  
10. println("{infBool.getClass()}");  
11. println("{infFlt.getClass()}");  
12. println("{infInt.getClass()}");  
13. println("{infStr.getClass()}");  
14. println("{varSome.getClass()}");  

println("Wnioskowanie:");
var infBool = true;
var infFlt = 1.0;
var infInt = 1;
var infStr = "chmielua@gmail.com";
var varSome;
println("infBool: {infBool},"
"infFlt: {infFlt}\ninfInt: {infInt}, infStr: {infStr}");
println("wynik dla zmiennej varSome: {varSome}");
println("{infBool.getClass()}");
println("{infFlt.getClass()}");
println("{infInt.getClass()}");
println("{infStr.getClass()}");
println("{varSome.getClass()}");

Wnioskowanie:
infBool: true,infFlt: 1.0
infInt: 1, infStr: chmielua@gmail.com
wynik dla zmiennej varSome: null
class java.lang.Boolean
class java.lang.Float
class java.lang.Integer
class java.lang.String
null

Jak widać JavaFX może automatycznie przyporządkować typ do zmiennych, i również jak na razie nie zgłosiła nam żadnego wyjątku dla zmiennej varSome dając mu wartość null.

Jak widzimy dla każdej naszej deklarowanej zmiennej poprzedzamy ja słowem kluczowym var ale Javafx ma również słowo kluczowe def jaka jest pomiędzy nimi różnica, mianowicie def'a nadajemy tym zmiennym których już później nie będziemy chcieli zmieniać, znaczy nie będziemy im zmieniać wartości, brzmi to dość znajomo i bynajmniej mi przypomina słowo kluczowe final

1. var moznaZmieniac:Integer = 5;  
2. def niemoznaZmieniac:Integer = 5;  
3. moznaZmieniac = 55;  
4. //niemoznaZmieniac = 55;  

var moznaZmieniac:Integer = 5;
def niemoznaZmieniac:Integer = 5;
moznaZmieniac = 55;
//niemoznaZmieniac = 55;

Znaki do wykonywania działań arytmetycznych w Javafx są takie same jak w Javie z 1 małym wyjątkiem mianowicie dla Javafx znak działania modulo wygląda następująco mod gdzie w Javie jak pamiętamy jest % poniżej przykład z rożnymi wariacjami:

1. def n1:Number = 1.5;  
2. def n2:Number = 2.0;  
3. var nAdd = n1 + n2;  
4. var nSub = n1 - n2;  
5. var nMul = n1 * n2;  
6. var nDiv = n1 / n2;  
7. var iNum = n1.intValue();  
8. println("nAdd = {nAdd}, nSub = {nSub}, "  
9. "nMul = {nMul}, nDiv = {nDiv}");  
10. println("iNum = {iNum}");  
11. var int1 = 10;  
12. var int2 = 10;  
13. int1 *= 2;  
14. int2 *= 5;  
15. var int3 = 9 mod (4+2*2);  
16. var num:Number = 1.0/(2.5).intValue();  
17. println("int1 = {int1}, int2 = {int2},"  
18. " int3 = {int3}, num = {num}");  

def n1:Number = 1.5;
def n2:Number = 2.0;
var nAdd = n1 + n2;
var nSub = n1 - n2;
var nMul = n1 * n2;
var nDiv = n1 / n2;
var iNum = n1.intValue();
println("nAdd = {nAdd}, nSub = {nSub}, "
"nMul = {nMul}, nDiv = {nDiv}");
println("iNum = {iNum}");
var int1 = 10;
var int2 = 10;
int1 *= 2;
int2 *= 5;
var int3 = 9 mod (4+2*2);
var num:Number = 1.0/(2.5).intValue();
println("int1 = {int1}, int2 = {int2},"
" int3 = {int3}, num = {num}");

nAdd = 3.5, nSub = -0.5, nMul = 3.0, nDiv = 0.75, iNum = 1

int1 = 20, int2 = 50, int3 = 1, num = 0.5

Następny przykład pokazuje operatory logiczne, zaszła w nich mała zmiana mianowicie w Javie mieliśmy do czynienia z || lub && tu zaś znaki te zostały zastąpione or i and reszta wydaje się być znajoma.

1. def testVal = 99;  
2. var flag1 = (testVal == 99);  
3. var flag2 = (testVal != 99);  
4. var flag3 = (testVal <= 100);  
5. var flag4 = (flag1 or flag2);  
6. var flag5 = (flag1 and flag2);  
7. var today:java.util.Date = new java.util.Date();  
8. var flag6 = (today instanceof java.util.Date);  
9. println("flag1 = {flag1}, flag2 = {flag2}, "  
10. "flag3 = {flag3}");  
11. println("flag4 = {flag4}, flag5 = {flag5}, "  
12. "flag6 = {flag6}");  

def testVal = 99;
var flag1 = (testVal == 99);
var flag2 = (testVal != 99);
var flag3 = (testVal <= 100);
var flag4 = (flag1 or flag2);
var flag5 = (flag1 and flag2);
var today:java.util.Date = new java.util.Date();
var flag6 = (today instanceof java.util.Date);
println("flag1 = {flag1}, flag2 = {flag2}, "
"flag3 = {flag3}");
println("flag4 = {flag4}, flag5 = {flag5}, "
"flag6 = {flag6}");

flag1 = true, flag2 = false, flag3 = true
flag4 = true, flag5 = false, flag6 = true

Rzutowanie i sprawdzanie typów słowa kluczowe:(as i instanceof). Żeby dokonać rzutowania używamy słówka as a do sprawdzenia typu używamy słówka instanceof, pokażę to na przykładzie:

1. //rzutowanie i sprawdzanie typu  
2. import java.lang.System;  
3. //System.currentTimeMillis() zwraca wartość Long,   
4. //a chcemy ją rzutować do Integer  
5. var pseudoRnd:Integer =  
6. (System.currentTimeMillis() as Integer) mod 1000;  
7. var asDouble: Double = 2.789;  
8. //var int_As: Integer = asDouble;  
9. var intAs: Integer = asDouble as Integer;  
10.   
11. //sprawdzanie typów  
12. var str:java.lang.Object = "A string";  
13. var inst1 = (str instanceof String);  
14. var inst2 = (str instanceof java.lang.Boolean);  
15. println("As:\n"  
16. "Integer z pseudoRnd: {pseudoRnd}\n"  
17. "Integer from intAs: {intAs}\n\n"  
18. "instanceof:\n"  
19. "String={inst1} Boolean={inst2}");  

//rzutowanie i sprawdzanie typu
import java.lang.System;
//System.currentTimeMillis() zwraca wartość Long, 
//a chcemy ją rzutować do Integer
var pseudoRnd:Integer =
(System.currentTimeMillis() as Integer) mod 1000;
var asDouble: Double = 2.789;
//var int_As: Integer = asDouble;
var intAs: Integer = asDouble as Integer;

//sprawdzanie typów
var str:java.lang.Object = "A string";
var inst1 = (str instanceof String);
var inst2 = (str instanceof java.lang.Boolean);
println("As:\n"
"Integer z pseudoRnd: {pseudoRnd}\n"
"Integer from intAs: {intAs}\n\n"
"instanceof:\n"
"String={inst1} Boolean={inst2}");

As:
Integer z pseudoRnd: 557
Integer from intAs: 2

instanceof:
String=true Boolean=false

Przyjrzymy sie teraz String'owi

1. //====================================================  
2. // string  
3. println("strings: ");  
4. def str1 = 'pojedynczy apostrof';  
5. def str2 = "podwójny apostrof";  
6. println("str1 = {str1}");  
7. println("str2 = {str2}");  
8.   
9. println("\nRozny zapis stringa");  
10. def multiline = "ten ciag zaczyna sie tu,"  
11. 'a konczy sie tu!';  
12. println("multiline = {multiline}");  
13. println("autorzy z UK wola 'pojedynczy apostrof'");  
14. println('autorzy z US wola "podwojny apostrof"');  
15. println("tutaj uzylismy apostrofu \"\" \n"  
16. 'a tutaj uzyjemy apostrofu \'\'');  
17.   
18. // string z wbudowanymi wyrażeniami  
19. println("\nstring z wbudowanymi wyrazeniami:");  
20. def rating = "cool";  
21. def eval1 = "JavaFX is {rating}!";  
22. def eval2 = "JavaFX is \{rating\}!";  
23. println("eval1 = {eval1}");  
24. println("eval2 = {eval2}");  
25. def flag = true;  
26. def eval3 =  
27. "JavaFX is {if(flag) "cool" else "uncool"}!";  
28. println("eval3 = {eval3}");  
29.   
30. // formatowanie stringa  
31. println("\nFormatowanie Stringa:");  
32. import java.util.Calendar;  
33. import java.util.Date;  
34. def magic = -889275714;  
35. //ta liczba daje CAFEBABE w hex'e  
36. //ale jest za duza dla Integer'a  
37. var magic_1 = 3405691582;  
38. println("magic class is: {magic.getClass()}");  
39. println("magic_1 class is: {magic_1.getClass()}");  
40. // tu dostaniemy zmienna magic rzutujac magic_1 na Integer  
41. println("magic_1 without formating: {magic_1 as Integer}");  
42. // %08x ten wlasnie format da nam hex'a   
43. println("{magic} in hex is {%08x magic}");  
44. println("{magic_1} in hex is {%08x magic_1}");  
45. def cal:Calendar = Calendar.getInstance();  
46. cal.set(1991,2,4);  
47. def joesBirthday:Date = cal.getTime();  
48. // %tA format dla daty  
49. println("Joe was born on a {%tA joesBirthday}");  
50. // end...  

//====================================================
// string
println("strings: ");
def str1 = 'pojedynczy apostrof';
def str2 = "podwójny apostrof";
println("str1 = {str1}");
println("str2 = {str2}");

println("\nRozny zapis stringa");
def multiline = "ten ciag zaczyna sie tu,"
'a konczy sie tu!';
println("multiline = {multiline}");
println("autorzy z UK wola 'pojedynczy apostrof'");
println('autorzy z US wola "podwojny apostrof"');
println("tutaj uzylismy apostrofu \"\" \n"
'a tutaj uzyjemy apostrofu \'\'');

// string z wbudowanymi wyrażeniami
println("\nstring z wbudowanymi wyrazeniami:");
def rating = "cool";
def eval1 = "JavaFX is {rating}!";
def eval2 = "JavaFX is \{rating\}!";
println("eval1 = {eval1}");
println("eval2 = {eval2}");
def flag = true;
def eval3 =
"JavaFX is {if(flag) "cool" else "uncool"}!";
println("eval3 = {eval3}");

// formatowanie stringa
println("\nFormatowanie Stringa:");
import java.util.Calendar;
import java.util.Date;
def magic = -889275714;
//ta liczba daje CAFEBABE w hex'e
//ale jest za duza dla Integer'a
var magic_1 = 3405691582;
println("magic class is: {magic.getClass()}");
println("magic_1 class is: {magic_1.getClass()}");
// tu dostaniemy zmienna magic rzutujac magic_1 na Integer
println("magic_1 without formating: {magic_1 as Integer}");
// %08x ten wlasnie format da nam hex'a 
println("{magic} in hex is {%08x magic}");
println("{magic_1} in hex is {%08x magic_1}");
def cal:Calendar = Calendar.getInstance();
cal.set(1991,2,4);
def joesBirthday:Date = cal.getTime();
// %tA format dla daty
println("Joe was born on a {%tA joesBirthday}");
// end...

Więcej na temat formatowania można znaleźć w klasie java.util.Formatter

Rozny zapis stringa
multiline = ten ciag zaczyna sie tu,a konczy sie tu!
autorzy z UK wola 'pojedynczy apostrof'
autorzy z US wola "podwojny apostrof"
tutaj uzylismy apostrofu "" 
a tutaj uzyjemy apostrofu ''

string z wbudowanymi wyrazeniami:
eval1 = JavaFX is cool!
eval2 = JavaFX is {rating}!
eval3 = JavaFX is cool!

Formatowanie Stringa:
magic class is: class java.lang.Integer
magic_1 class is: class java.lang.Long
magic_1 without formating: -889275714
-889275714 in hex is cafebabe
3405691582 in hex is cafebabe
Joe was born on a Monday

Przejdziemy teraz chyba do najciekawszego elementu w tym języku jakim jest interwał czasowy, zmienna Duration. Aby ja zdeklarować trzeba poznać kilka literałów.

jednostka czasu	skrót jednostki czasu
milisekundy	ms
sekundy	s
minuty	m
godziny	h

Zaś deklarowanie ich wygląda następująco:

def mil = 300ms;

I tu mamy przykład zadeklarowania każdej takiej zmiennej:

1. // line 1  
2. println("Deklaracja zmiennej typu Duration:");  
3. def mil = 25ms;  
4. def sec = 30s;  
5. def min = 15m;  
6. def hrs = 2h;  
7. println("mil = {mil}, sec = {sec}, "  
8. "min = {min}, hrs = {hrs}");  
9.   
10. println("\nDzialania arytmetyczne na zmiennej czasu:");  
11. def dur1 = 15m * 4;  
12. def dur2 = 0.5h * 2;  
13. def flag_1 = (dur1 == dur2);  
14. def flag_2 = (dur1 > 55m);  
15. def flag_3 = (dur2 < 123ms);  
16. System.out.printf(  
17. "dur1 = {dur1.toMinutes()}m , "  
18. "dur2 = {dur2.toMinutes()}m%n"  
19. "(dur1 == dur2) is {flag_1}%n"  
20. "(dur1 > 55m) is {flag_2}%n"  
21. "(dur1 < 123ms) is {flag_3}%n");  

// line 1
println("Deklaracja zmiennej typu Duration:");
def mil = 25ms;
def sec = 30s;
def min = 15m;
def hrs = 2h;
println("mil = {mil}, sec = {sec}, "
"min = {min}, hrs = {hrs}");

println("\nDzialania arytmetyczne na zmiennej czasu:");
def dur1 = 15m * 4;
def dur2 = 0.5h * 2;
def flag_1 = (dur1 == dur2);
def flag_2 = (dur1 > 55m);
def flag_3 = (dur2 < 123ms);
System.out.printf(
"dur1 = {dur1.toMinutes()}m , "
"dur2 = {dur2.toMinutes()}m%n"
"(dur1 == dur2) is {flag_1}%n"
"(dur1 > 55m) is {flag_2}%n"
"(dur1 < 123ms) is {flag_3}%n");

Deklaracja zmiennej typu Duration:
mil = 25ms, sec = 30000ms, min = 900000ms, hrs = 7200000ms

Dzialania arytmetyczne na zmiennej czasu:
dur1 = 60.0m , dur2 = 60.0m
(dur1 == dur2) is true
(dur1 > 55m) is true
(dur1 < 123ms) is false

"Tablice" lub lepiej sekwencje, kilka ważnych punktów:

• Tablice deklarujemy poprzez dodanie nawiasu kwadratowego [].
• Jeżeli użyjemy tablicy w tablicy, to tablica ta będzie rozszerzona w tym miejscu w którym użyliśmy drugiej tablicy. Czyli wszystkie tablice będą liniowe, wielowymiarowe tablice nie są stosowane (dozwolone).
• Tablice są sobie równe jeśli mają taki sam rozmiar i zawierają te same wartości w tym samym porządku.
• Każda tablica jest sekwencją obiektów zdeklarowanych przed nawiasem [], tzn. np. String[] odnosi się do sekwencji obiektów String'a
• operator sizeof może być użyty do określenia długości tablicy

W paru przykładach postaram się pokazać wszystkie sposoby inicjalizacji tablic, w komentarzach będę dawał krótkie objaśnienia w przypadku jakiś większych czarów:

1. // tablice, albo lepiej - sekwencje  
2. println("\n");  
3. println("Deklaracja tablic");  
4. def seq1:String[] = [ "A" , "B" , "C" ];  
5. def seq2:String[] = [ seq1 , "D" , "E" ];  
6. def flag_01 = (seq2 == ["A","B","C","D","E"]);  
7. def size = sizeof seq1;  
8. System.out.printf("seq1 = {seq1.toString()}%n"  
9. "seq2 = {seq2.toString()}%n"  
10. "flag1 = {flag_01}%n"  
11. "size = {size}%n");  
12.   
13. println("\nInny sposob deklarowania:");  
14. def faceCards = [ "Jack" , "Queen" , "King" ];  
15. // umieszczamy w tablicy rozne typy danych, czy napewno?  
16. var array_mix = [ "Jack" , "Queen" , 34, "King", true];  
17. // zwiekszamy sobie tablice  
18. array_mix[5] = 3.4;  
19. // tak nie mozna:  
20. // var array_mix2:String[] = [ "Jack" , "Queen" , 34, "King", true];  
21. var king = faceCards[2];  
22. def ints = [10,11,12,13,14,15,16,17,18,19,20];  
23. var oneInt = ints[3];  
24. var outside = ints[-1];  
25. var tofar = ints[11];  
26. System.out.printf("faceCards[2] = {king}\n"  
27. "ints[3] = {oneInt}\n"  
28. //nie da nam wyjatku, przypisze wartosci domyslne  
29. "ints[-1] = {outside}\n"  
30. "ints[11] = {tofar}\n");  
31. println("faceCards is class: \n{faceCards.getClass()}");  
32. println("Sprawdzamy czy napewno mamy mix w tab:\n"  
33. "array_mix[2] is class {array_mix[2].getClass()}\n"  
34. "array_mix[4] is class {array_mix[4].getClass()}\n"  
35. "array_mix[5] is class {array_mix[5].getClass()}");  
36. println("tak mozemy mieszac typy danych w tablicy\n");  
37.   
38. println("Tworzenie tablic przy pomocy [ .. ] i step :");  
39. def seq3 = [ 1 .. 10 ];  
40. var negative = [-3..3];  
41. println("seq3 = {seq3.toString()}");  
42. println("negative = {negative.toString()}\n");  
43. def range1 = [0..40 step 5];  
44. def range2 = [40..0 step -5];  
45. def negative_step = [-6..2 step 2];  
46. // zglasza wyjatek empty sequence  
47. //def negative_step2 = [-6..2 step -2];  
48. //def range3 = [0..100 step -5];  
49. def range4 = [0.0 .. 1.0 step 0.25];  
50. println("range1 = {range1.toString()}");  
51. println("range2 = {range2.toString()}");  
52. println("range4 = {range4.toString()}");  
53. println("negative_step = {negative_step.toString()}\n");  
54. def someArray = [9,0,8];  
55. def blackjackValues = [ [4..7] , 10,10, [1..3], someArray];  
56. println("blackjackValues = \n"  
57. "{blackjackValues.toString()}\n");  
58.   
59. def source = [0 .. 100];  
60. var slice1 = source[5 .. 10];  
61. var slice2 = source[5 ..< 10];  
62. var slice3 = source[95..];  
63. var slice4 = source[95..<];  
64. var format = "%s = %d to %d%n";  
65. System.out.printf(format, "slice1",  
66. slice1[0], slice1[(sizeof slice1)-1] );  
67. System.out.printf(format, "slice2",  
68. slice2[0], slice2[(sizeof slice2)-1] );  
69. System.out.printf(format, "slice3",  
70. slice3[0], slice3[(sizeof slice3)-1] );  
71. System.out.printf(format, "slice4",  
72. slice4[0], slice4[(sizeof slice4)-1]);  
73.   
74. println("");  
75. def source2 = [0 .. 9];  
76. // co to za znak (n|) - oznacza to nam orzeczenie  
77. // za n mozemy wstawic dowolna literke  
78. // czyli mowimy ze jesli jakas rzecz jest w tablicy  
79. // mniejsza od 5 (n<5) to ma byc dodana do naszej   
80. // tablicy lowVals  
81. var lowVals = source2[n|n<5];  
82. println("lowVals = {lowVals.toString()}");  
83. def people =  
84. ["Alan","Andy","Bob","Colin","Dave","Eddie"];  
85. var peopleSubset =  
86. people[s | s.startsWith("A")].toString();  
87. println("predicate = {peopleSubset}\n");  
88.   
89. println("komenda insert: ");  
90. var seq_1 = [1..5];  
91. insert 6 into seq_1;  
92. println("Insert1: {seq_1.toString()}");  
93. insert 0 before seq_1[0];  
94. println("Insert2: {seq_1.toString()}");  
95. insert 99 after seq_1[2];  
96. println("Insert3: {seq_1.toString()}\n");  
97.   
98. println("polecenie delete:");  
99. var seq_2 = [[1..10],10];  
100. delete seq_2[0];  
101. println("Delete1: {seq_2.toString()}");  
102. delete seq_2[0..2];  
103. println("Delete2: {seq_2.toString()}");  
104. delete 10 from seq_2;  
105. println("Delete3: {seq_2.toString()}");  
106. delete seq_2;  
107. println("Delete4: {seq_2.toString()}\n");  
108.   
109. println("Polecenie reverse:");  
110. var seq_3 = [1..10];  
111. seq_3 = reverse seq_3;  
112. println("Reverse1: {seq_3.toString()}");  
113. seq_3 = reverse seq_3[8];  
114. println("Reverse2: {seq_3.toString()}");  
115. seq_3 = [1..10];  
116. println("Przed reverse: {seq_3.toString()}");  
117. seq_3 = reverse seq_3[4..7];  
118. println("Reverse3: {seq_3.toString()}");  

// tablice, albo lepiej - sekwencje
println("\n");
println("Deklaracja tablic");
def seq1:String[] = [ "A" , "B" , "C" ];
def seq2:String[] = [ seq1 , "D" , "E" ];
def flag_01 = (seq2 == ["A","B","C","D","E"]);
def size = sizeof seq1;
System.out.printf("seq1 = {seq1.toString()}%n"
"seq2 = {seq2.toString()}%n"
"flag1 = {flag_01}%n"
"size = {size}%n");

println("\nInny sposob deklarowania:");
def faceCards = [ "Jack" , "Queen" , "King" ];
// umieszczamy w tablicy rozne typy danych, czy napewno?
var array_mix = [ "Jack" , "Queen" , 34, "King", true];
// zwiekszamy sobie tablice
array_mix[5] = 3.4;
// tak nie mozna:
// var array_mix2:String[] = [ "Jack" , "Queen" , 34, "King", true];
var king = faceCards[2];
def ints = [10,11,12,13,14,15,16,17,18,19,20];
var oneInt = ints[3];
var outside = ints[-1];
var tofar = ints[11];
System.out.printf("faceCards[2] = {king}\n"
"ints[3] = {oneInt}\n"
//nie da nam wyjatku, przypisze wartosci domyslne
"ints[-1] = {outside}\n"
"ints[11] = {tofar}\n");
println("faceCards is class: \n{faceCards.getClass()}");
println("Sprawdzamy czy napewno mamy mix w tab:\n"
"array_mix[2] is class {array_mix[2].getClass()}\n"
"array_mix[4] is class {array_mix[4].getClass()}\n"
"array_mix[5] is class {array_mix[5].getClass()}");
println("tak mozemy mieszac typy danych w tablicy\n");

println("Tworzenie tablic przy pomocy [ .. ] i step :");
def seq3 = [ 1 .. 10 ];
var negative = [-3..3];
println("seq3 = {seq3.toString()}");
println("negative = {negative.toString()}\n");
def range1 = [0..40 step 5];
def range2 = [40..0 step -5];
def negative_step = [-6..2 step 2];
// zglasza wyjatek empty sequence
//def negative_step2 = [-6..2 step -2];
//def range3 = [0..100 step -5];
def range4 = [0.0 .. 1.0 step 0.25];
println("range1 = {range1.toString()}");
println("range2 = {range2.toString()}");
println("range4 = {range4.toString()}");
println("negative_step = {negative_step.toString()}\n");
def someArray = [9,0,8];
def blackjackValues = [ [4..7] , 10,10, [1..3], someArray];
println("blackjackValues = \n"
"{blackjackValues.toString()}\n");

def source = [0 .. 100];
var slice1 = source[5 .. 10];
var slice2 = source[5 ..< 10];
var slice3 = source[95..];
var slice4 = source[95..<];
var format = "%s = %d to %d%n";
System.out.printf(format, "slice1",
slice1[0], slice1[(sizeof slice1)-1] );
System.out.printf(format, "slice2",
slice2[0], slice2[(sizeof slice2)-1] );
System.out.printf(format, "slice3",
slice3[0], slice3[(sizeof slice3)-1] );
System.out.printf(format, "slice4",
slice4[0], slice4[(sizeof slice4)-1]);

println("");
def source2 = [0 .. 9];
// co to za znak (n|) - oznacza to nam orzeczenie
// za n mozemy wstawic dowolna literke
// czyli mowimy ze jesli jakas rzecz jest w tablicy
// mniejsza od 5 (n<5) to ma byc dodana do naszej 
// tablicy lowVals
var lowVals = source2[n|n<5];
println("lowVals = {lowVals.toString()}");
def people =
["Alan","Andy","Bob","Colin","Dave","Eddie"];
var peopleSubset =
people[s | s.startsWith("A")].toString();
println("predicate = {peopleSubset}\n");

println("komenda insert: ");
var seq_1 = [1..5];
insert 6 into seq_1;
println("Insert1: {seq_1.toString()}");
insert 0 before seq_1[0];
println("Insert2: {seq_1.toString()}");
insert 99 after seq_1[2];
println("Insert3: {seq_1.toString()}\n");

println("polecenie delete:");
var seq_2 = [[1..10],10];
delete seq_2[0];
println("Delete1: {seq_2.toString()}");
delete seq_2[0..2];
println("Delete2: {seq_2.toString()}");
delete 10 from seq_2;
println("Delete3: {seq_2.toString()}");
delete seq_2;
println("Delete4: {seq_2.toString()}\n");

println("Polecenie reverse:");
var seq_3 = [1..10];
seq_3 = reverse seq_3;
println("Reverse1: {seq_3.toString()}");
seq_3 = reverse seq_3[8];
println("Reverse2: {seq_3.toString()}");
seq_3 = [1..10];
println("Przed reverse: {seq_3.toString()}");
seq_3 = reverse seq_3[4..7];
println("Reverse3: {seq_3.toString()}");

Deklaracja tablic
seq1 = [ A, B, C ]
seq2 = [ A, B, C, D, E ]
flag1 = true
size = 3

Inny sposub deklarowania:
faceCards[2] = King
ints[3] = 13
ints[-1] = 0
ints[11] = 0
faceCards is class: 
class com.sun.javafx.runtime.sequence.ObjectArraySequence
Sprawdzamy czy napewno mamy mix w tab:
array_mix[2] is class class java.lang.Integer
array_mix[4] is class class java.lang.Boolean
array_mix[5] is class class java.lang.Float
tak mozemy mieszac typy danych w tablicy

Tworzenie tablic przy pomocy [ .. ] i step :
seq3 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
negative = [ -3, -2, -1, 0, 1, 2, 3 ]

range1 = [ 0, 5, 10, 15, 20, 25, 30, 35, 40 ]
range2 = [ 40, 35, 30, 25, 20, 15, 10, 5, 0 ]
range4 = [ 0.0, 0.25, 0.5, 0.75, 1.0 ]
negative_step = [ -6, -4, -2, 0, 2 ]

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

slice1 = 5 to 10
slice2 = 5 to 9
slice3 = 95 to 100
slice4 = 95 to 99

lowVals = [ 0, 1, 2, 3, 4 ]
predicate = [ Alan, Andy ]

komenda insert: 
Insert1: [ 1, 2, 3, 4, 5, 6 ]
Insert2: [ 0, 1, 2, 3, 4, 5, 6 ]
Insert3: [ 0, 1, 2, 99, 3, 4, 5, 6 ]

polecenie delete:
Delete1: [ 2, 3, 4, 5, 6, 7, 8, 9, 10, 10 ]
Delete2: [ 5, 6, 7, 8, 9, 10, 10 ]
Delete3: [ 5, 6, 7, 8, 9 ]
Delete4: [ ]

Polecenie reverse:
Reverse1: [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
Reverse2: [ 2 ]
Przed reverse: [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
Reverse3: [ 8, 7, 6, 5 ]

W sumie dość fajnie, rzadko kiedy mamy problem z błędami, wszystko ładnie się samo automatyzuje, jak coś źle zapiszemy środowisko krzyczy za nas samych że jest tu coś nie tak. No własnie, ale co będzie w sytuacjach kiedy popełnimy błąd podczas naszych przeliczeń, i aplikacja bedzie robiła całkiem co innego niż potrzebujemy. Czy czasem wtedy nie zajmie to nam zbyt dużo czasu, aby znaleźć błąd. Wszystko się okaże idąc dalej i tworząc coraz poważniejsze skrypty w Javafx. Większość przykładów które tu są były zawarte w książce, z mojego lenistwa nie chciało mi się ich zmieniać po zapoznaniu się z tym co i jak pracuje, ale w niektórych przypadkach, zwłaszcza tam gdzie chciałem coś przetestować to uzupełniałem to swoimi przykładami. Następnym razem postaram się to poprawić zwłaszcza że przykłady będą coraz ciekawsze, no i trudniejsze ;)

---