Apakah JavaFX itu?.

JavaFX adalah framework open source berbasis java yang digunakan untuk membangun aplikasi
client. JavaFX bisa dibandingkan dengan framework lain semisal Adobe Flex dan Microsoft
Silverlight. Java FX juga bisa mendukung Swing dalam membangun GUI di pemrograman Java.
Library JavaFX tersedia sebagai public Java API. JavaFX mengandung berbagai fitur yang
membuatnya menjadi pilihan dalam membangun banyak aplikasi client antara lain:
- JavaFX ditulis dalam bahasa pemrograman Java, yang mengizinkan kita untuk
menggunakan semua fitur dalam java, misalnya multithreading, generics dan lambda
expression. Kita juga bisa menggunakan berbagai editor java seperti netbeans, untuk
melakukan compile, run, debug, dsb untuk aplikasi JavaFX yang kita buat.
- JavaFX mendukung data binding.
- Kode JavaFX dapat ditulis menggunakan banyak JVM.
- JavaFX menawarkan dua cara dalam membangun user interface (UI): menggunakan kode
Java dan menggunakan FXML.
- JavaFX memberikan banyak dukungan multimedia, seperti memainkan audio dan video.
- JavaFX memungkinkan kita menanamkan konten web di dalam aplikasi.
Kebutuhan sistem
kita memerlukan beberapa software yang terinstal pada komputer kita, yaitu:
- Java Development Kit 8
- NetBeans 8 atau yang lebih baru
Selain menggunakan NetBeans, kita juga bisa menggunakan IDE alternatif lainnya, sebagai
contoh, Eclipse, JDeveloper, IntelliJ IDEA, dsb.

Aplikasi JavaFX Pertama Kita

Di sini, kita coba untuk membuat aplikasi yang bisa menampilkan teks “Hallo JavaFX” di
jendela(window). Saya akan menjelaskan langkah demi langkah bagaimana membuat aplikasi
ini. Saya juga akan menambahkan sedikit mungkin kode, lalu menjelaskan mengapa kode
tersebut diperlukan.
Membuat kelas HalloJavaFX
Tiap aplikasi JavaFX adalah sebuah class yang harus diturunkan dari class Application yang
ada di paket javafx.application. kita beri nama HalloFXApp untuk class yang kita buat,
lalu kita letakkan di paket com.jdojo.intro. Listing 1-1 menampilkan potongan kode dari
class HalloFXApp. Yang perlu diperhatikan, class HalloFXApp belum bisa di compile, kita
perlu melanjutkan pada seksi selanjutnya.

Listing 1- 1
Meng-Override method start()
Jika kita coba meng-compile class HelloFXApp, maka akan menghasilkan pesan error:
HelloFXApp is not abstract and does not override abstract method start(Stage) in Application.
Kesalahan ini berarti bahwa class Application mengandung sebuah method abstract
start(Stage stage), yang belum di-override di dalam class HelloFXApp. Sebagai
developer java, kita mengetahui apa yang selanjutnya harus dilakukan: mendeklarasikan class
HelloFXApp sebagai abstrak atau mengimplementasikan method start(). Di sini yang
diperlukan adalah mengimplementasikan method start(). Listing 1-2 menampilkan perbaikan
kode pada class HelloFXApp.

Listing 1- 2

Dari perbaikan yang dilakukan di atas, ada dua hal yang perlu diperhatikan, yaitu:
1. Kita telah menambahkan statement import class Stage dari package javafx.stage.
2. Kita telah mengimplementasikan method start().
Method start() adalah poin utama dalam aplikasi JavaFX. Method ini dipanggil oleh JavaFX
Application launcher.
Menampilkan Stage
Sama halnya dengan stage (panggung) di dunia nyata, stage di JavaFX digunakan untuk
menampilkan scene. Sebuah scene adalah hal yang tampak – seperti teks, shapes, image,
animasi, efek – yang digunakan pengguna untuk berinteraksi dengan aplikasi.
Di JavaFX, stage utama(primary stage) adalah tempat untuk scene. Stage secara tampilan
berbeda tergantung dari lingkungan kerja(environment) aplikasi kita berjalan. Kita tidak
memerlukan basis action dalam environment, karena JavaFX runtime memberikan semuanya
secara detail untuk kita. Sebagai contoh, jika aplikasi berjalan sebagai aplikasi desktop, maka
stage utamanya adalaha sebuah window dengan title bar dan area untuk menampilkan scene. Jika
aplikasi berjalan sebagai applet di web browser, maka stage utamanya adalah area di dalam
jendela browser.
Stage utama dibuat oleh application launcer yang tidak mempunyai scene. Kita akan membuat
scene untuk stage kita pada kesempatan yang lain.
Kita perlu menampilkan stage untuk melihat visual yang terkandung dalam scene. Gunakan
method show() untuk menampilkan stage. Kita bisa mengatur judul(title) menggunakan
method setTitle(). Perhatikan perubahan kode pada class HelloFXApp pada Listing 1-3.
Listing 1- 3 : Menampilkan Stage utama

Meluncurkan aplikasi
Kita sudah siap untuk menjalankan aplikasi JavaFX pertama kita. Kita bisa menggunakan dua
opsi untuk menjalankannya:
1. JavaFX tidak memerlukan method main() untuk memulai aplikasi. Ketika kita
menjalankan class di Java yang merupakan turunan dari class Application, Java akan
memerintahkan meluncurkan (launch) aplikasi JavaFX jika class yang akan berjalan tidak
mengandung method main().
2. Jika kita menambahkan method main() dalam aplikasi JavaFX, maka kita perlu
memanggil method launch() untuk menjalankan aplikasi. Method launch() akan
melewatkan sebuah array String sebagai parameter ke aplikasi JavaFX.
Jika kita menggunakan opsi pertama, kita tidak perlu menulis banyak kode tambahan untuk class
HelloFXApp. Jika kita menggunakan opsi yang kedua, diperlukan tambahan kode untuk class
HelloFXApp yaitu method main() yang akan ditampilkan pada Listing 1-4.

Method main() memanggil method launch(), yang akan melakukan beberapa pekerjaan setup dan
juga memanggil method start() pada class HelloFXApp. Method start() menentukan title untuk
stage utama dan menampilkan stage. Lihat gambar 1-1.

Gambar 1- 1: Aplikasi HelloFXApp tanpa scene

3. Area utama di window terlihat kosong. Ini adalah area konten di mana stage akan
menampilkan scene. Karena kita belum memiliki scene, maka stage terlihat kosong. Title
 bar menampilkan judul yang telah diatur di method start(). Kita bisa menutup
aplikasi menggunakan tombol close di pojok kanan atas, atau menggunakan tombol
Alt+F4.

Listing 1- 4: aplikasi HelloFXApp tanpa scene

Menambahkan Method main()

Sebagaimana telah dijelaskan sebelumnya, Java 8 tidak memerlukan method main() untuk
menjalankan aplikasi JavaFX. Jika class yang dijalankan adalah turunan dari class Application,
maka aplikasi JavaFX akan otomatis memanggil method Application.launch().
Jika kita menggunakan IDE NetBeans untuk membuat proyek JavaFX, kita tidak memerlukan
method main() untuk menjalankan aplikasi JavaFX jika kita menjalankannya dari proyek
JavaFX tersebut. Meskipun demikian, IDE NetBeans memerlukan method main() ketika kita
menjalankan aplikasi melalui filenya, sebagai contoh, kita klik kanan pada file HelloFXApp,
lalu pilih Run File
Beberapa IDE masih memerlukan method main() untuk menjalankan aplikasi JavaFX. Semua
contoh pada bab ini akan memasukkan method main() untuk menjalankan aplikasi JavaFX.
Menambahkan Scene ke dalam Stage
Sebuah instance dari class Scene, yang ada di dalam package javafx.scene, menggambarkan
sebuah scene. Sebuah stage mengandung satu scene, dan sebuah scene mengandung konten-
konten visual.
Konten dari scene diatur menyerupai hirarki pohon. Hirarki teratas disebut root node. Root node
bisa mengandung child node, yang mana juga bisa memiliki child node lagi. Kita harus memiliki
root node untuk membuat sebuah scene. Kita bisa menggunakan VBox sebagai root node. VBox
adalah Box vertikal, yang mana mengatur letak child node secara vertikal di dalam sebuah
kolom. Perhatikan statement membuat VBox di bawah ini:
Vbox root = new VBox();

Sebuah node bisa membuat anak menggunakan method getChildren() yang akan
mengembalikan sebuah ObservableList untuk anak tersebut. Untuk menambahkan child node,
sederhananya menambahkan child node ke dalam ObservableList. Perhatikan potongan kode
di bawah ini untuk menambahkan Text node ke dalam VBox:
//membuat VBox
VBox root = new VBox();
//membuat Text node
Text msg = new Text(“Hello JavaFX”);
//menambahkan text node ke dalam VBox sebagai child node
Root.getChildren().add(msg);

Class Scene mengandung beberapa constructor. Kita akan menggunakan salah satu untuk
menentukan ukuran root node di dalam scene. Statemen di bawah ini membuat scene dengan
VBox sebagai root node, dengan ketentuan lebar 300px dan tinggi 50px:
//membuat scene
Scene scene = new Scene(root, 300, 50);

Kita juga perlu menentukan scene ke dalam stage dengan memanggil method setScene() pada
class Stage:
Stage.setScene(scene);

Perhatikan Listing 1-5 untuk kode program yang lengkap, dan hasilnya pada Gambar 1-2.

Listing 1- 5
Gambar 1- 2

Memperbaiki Aplikasi JavaFX

JavaFX sebenarnya mampu melakukan lebih dari yang kita lihat sejauh ini. Selanjutnya, kita
akan meningkatkan program pertama sebelumnya dan menambah lebih banyak komponen user
interface seperti tombol dan form inputan. Sehingga, pengguna bisa berinteraksi dengan aplikasi.
Gunakan sebuah instance dari class Button untuk membuat sebuah tombol, seperti di bawah ini:
Button exitBtn = new Button(“Exit”);

Ketika tombol tersebut di-klik, akan menuju ke sebuah EctionEvent. Kita bisa menambahkan
ActionEvent handler untuk menangani event tersebut. Gunakan method setOnAction()
untuk mengatur ActionEvent handler dari tombol. Statement berikut ini menangani
ActionEvent handler untuk button. Handler ini akan menutup aplikasi. Kita dapat menggunakan
pernyataan lambda atau class yang tidak dikenal untuk mengatur ActionEvent handler.
Perhatikan potongan kode di bawah ini:
//menggunakan ekspresi lambda
exitBtn.setOnAction(e -> Platform.exit());
//menggunakan class anonymous(tidak dikenal)
Import javafx.event.ActionEvent;
Import javafx.event.EventHandler;
...
exitBtn.setOnAction(new EventHandler<ActionEvent>(){
@Override
Public void handle(ActionEvent e){
Platform.exit;
}
});

Program dalam Listing 1-6 menampilkan bagaimana menambah node ke dalam scene. Progam
menggunakan method setStyle() pada class Label untuk mengatur warna menjadi biru. Saya
akan mendiskusikan penggunaan CSS ke dalam JavaFX pada kesempatan lain.
Listing 1- 6: Berinteraksi dengan pengguna di Aplikasi JavaFX
Gambar 1- 3: Aplikasi JavaFX yang menampilkan control ke dalam scene

Melewatkan Parameter di Aplikasi JavaFX

Seperti Aplikasi Java umumnya, kita juga bisa melewatkan parameter untuk aplikasi JavaFX.
Ada dua cara untuk melewatkan parameter di aplikasi JavaFX, yaitu:
1. Melalui command line pada aplikasi mandiri.
2. Melalui file Java Network Launching Protocol (JNLP) untuk applet dan aplikasi
WebStart.
Class Parameters, yang merupakan inner class static dari class Application, meng-encapsulasi
parameter yang dilewatkan ke aplikasi JavaFX. Parameter dibagi ke dalam tiga kategori, yaitu:
1. Parameter bernama (named parameters)
2. Parameter tak bernama (unnamed parameters)
3. Raw parameter(kombinasi dari parameter bernama dan tak bernama)
Kita perlu menggunakan tiga method dari class Parameters di bawah ini untuk mengakses tiga
tipe parameter di atas:
1. Map<String, String> getNamed()
2. List<String> getUnnamed()
3. List<String> getRaw()

Sebuah parameter bisa bernama ataupun tidak bernama. Parameter bernama terdiri dari (nama,
nilai). Parameter tak bernama terdiri dari nilai tunggal. Method getNamed() mengembalikan
Map<String, String> yang mengandung sepasang nilai-kunci dari parameter nama. Method
getUnnamed() mengembalikan List<String>, di mana setiap elemen adalah nilai dari
parameter tak bernama.
Kita hanya melewatkan parameter bernama dan tak bernama saja untuk aplikasi JavaFX. Jangan
melewatkan parameter bertipe raw. JavaFX runtime membuat semua parameter, bernama dan tak
bernama, yang dilewatkan ke dalam aplikasi sebagai List<String> di luar method getRaw()
pada class Parameters.
Method getParameters() pada class Application mengembalikan referensi ke class
Application.Parameters. referensi untuk class Parameters tersebut terdapat di dalam
method init() pada class Application dan kode yang dieksekusi setelah itu. Parameter
tersebut tidak terdapat di dalam constructor pada aplikasi yang dipanggil sebelum method
init(). Pemanggilan method getParameters() di dalam constructor akan mengembalikan
nilai null.
Program pada Listing 1-7 membaca semua tipe melewatkan parameter ke dalam aplikasi dan
menampilkannya ke dalam TextArea. TextArea adalah node yang menampilkan teks dengan
banyak baris.
Listing 1- 7

Siklus Hidup(Life Cycle) Aplikasi JavaFX

JavaFX runtime membuat beberapa thread. Pada stage yang berbeda di aplikasi, thread
digunakan untuk melaksanakan beberapa perintah yang berbeda. Saya hanya akan menjelaskan
thread yang digunakan untuk memanggil method dari class Aplikasi selama siklus hidup.
JavaFX runtime membuat dua thread, di antara thread lainnya, yaitu:
1. JavaFX-Launcher
2. JavaFX ApplicationThread
Method launch() pada class Application membuat thread ini. Selama aplikasi JavaFX
berjalan, JavaFX runtime memanggil method yang dibuat di class Application, yaitu:
- Constructor no-args
- Method init()
 - Method start()
- Method stop()
JavaFX runtime membuat objek dari class Application ke dalam thread JavaFX Application.
Thread JavaFX Launcher memanggil method init() yang dideklarasikan di class
Application. Method init() yang diimplementasikan di dalam class Application masih
kosong. Kita bisa meng-override method ini di class aplikasi kita. Tetapi tidak diizinkan untuk
membuat Stage atau Scene di dalam Thread JavaFX Launcher. Stage dan Scene harus dibuat di
dalam Thread JavaFX Application. Oleh karena itu, kita tidak boleh membuat Stage atau Scene
di dalam method init(). Hal ini akan mempermudah membuat kontrol UI, misalnya Button
atau shape.
Thread JavaFX Application akan memanggil method start(Stage stage) yang ada di class
Application. Perlu diperhatikan bahwa method start() pada class Application bersifat
abstrak, sehingga kita perlu meng-override method tersebut pada class aplikasi kita nanti.
Sampai poin ini, method launch() masih menunggu aplikasi JavaFX selesai. Ketika aplikasi
selesai, maka Thread JavaFX Application akan memanggil method stop() yang ada di class
Application. Kita juga perlu meng-override method tersebut ke dalam class aplikasi kita
untuk menjalankan aksi yang kita tentukan ketika aplikasi berhenti.
Kode pada Listing 1-8 mengilustrasikan siklus hidup dari aplikasi JavaFX. Aplikasi akan
menampilkan stage kosong, kita akan lihat tiga baris pertama yang keluar ketika stage tampil.
Kita perlu menutup stage untuk melihat baris terakhir yang dikeluarkan.
Listing 1- 8: Siklus hidup dari aplikasi JavaFX
 PROPERTIES AND BINDING

Apakah yang dimaksud properti?

Class dalam Java mengandung dua bagian: field dan method. Field merepresentasikan objek yang
dideklarasikan sebagai private. Sedangkan method public, yang dikenal sebagai
accessor(pengakses) atau setter dan getter, digunakan untuk membaca dan memodifikasi field
private. Sederhananya adalah, sebuah class Java yang memiliki accessor public untuk semua atau
sebagian dari field private, yang kita kenal sebagai Java bean, dan eccessor ini mendefinisikan
properti dari bean tersebut. Properti Java bean ini bisa diatur lagi keadaan atau tingkah lakunya.
Java bean selalu kelihatan. Dan juga mendukung adanya pemberitahuan perubahan properti.
Ketika sebuah properti publik dari java bean diubah, maka pemberitahuan dikirim ke semua
listener.
Intinya adalah, Java bean mendefinisikan komponen reusable yang bisa dirangkai/dirakit oleh
builder untuk membuat aplikasi java. Hal ini membuka pintu bagi pihak ketiga untuk membangun
java bean dan bisa digunakan oleh lainnya.
Properti dapat bersifat read-only, write-only, atau read/write. Properti yang bersifat read-only
hanya memiliki sebuah getter. Sedangkan write-only hanya memiliki setter. Tetapi properti
read/write memiliki kedua-duanya.
IDE Java atau software bantu lainnya, menggunakan introspection untuk mendapatkan daftar
properti dari bean sehingga kita bisa memanipulasi properti-properti waktu mendesain. Java bean
bisa bersifat visual ataupun non visual.
JavaBeans API memberikan sebuah library, melalui package java.beans, sebuah nama yang umum
untuk membuat dan menggunakan java bean. Contoh di bawah ini adalah sebuah bean Person
dengan baca/tulis properti name. Method getName() mengembalikan nilai field name. Method
setName() mengatur nilai dari field name:
package com.djojo.binding;

public class Person {

private String name;

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}
}

Sesuai dengan konvensi, nama dari method getter dan setter disusun oleh nama properti, dengan
huruf pertama besar, setelah kata get dan set.method getter tidak mempunyai suatu parameter, dan
mengembalikan tipe data yang sama dengan tipe dari field. Method setter memiliki parameter yang
bertipe data sama dengan tipe data field, dan tipe kembaliannya adalah void.
Perhatikan potongan kode untuk memanipulasi properti name dari sebuah bean Person:

Person p = new Person();

p.setName("John Jacobs");
String name = p.getName();
Apakah yang dimaksud Binding/Ikatan
Di dunia programming, istilah binding digunakan di banyak konteks yang berbeda. Di sini, saya
ingin menjelaskannya dalam konteks data binding. Data binding didefinisikan sebagai hubungan
antara elemen data (biasanya berupa variabel) di sebuah program sehingga tetap tersinkronisasi
satu dengan lainnya. Di aplikasi berbasis GUI, data binding sering digunakan untuk
menyinkronkan elemen pada model data dengan elemen UI.
Perhatikan pernyataan berikut, diasumsikan bahwa x, y, dan z adalah variabel numerik:

X = y + z;

Pernyataan di atas mendefinisikan sebuah binding antara x, y, dan z. Ketika dieksekusi, nilai x
adalah sama dengan jumlah y dan z. Binding juga mempunyai faktor waktu. Dari pernyataan di
atas, nilai dari x dibatasi oleh jumlah y dan z dan bernilai valid waktu pernyataan tersebut
dieksekusi. Nilai dari x bukanlah jumlah dari y dan z sebelum dan sesudah pernyataan tersebut
dieksekusi.
Terkadang diperlukan sebuah binding untuk menangani lebih dari satu periode. Perhatikan
pernyataan di bawah ini yang mendefinisikan binding menggunakan harga, diskon, dan pajak:

hargaJual = harga – diskon + pajak;

Dari kasus ini, kita ingin menjaga binding tetap valid, sehingga harga jual terhitung dengan benar,
bila mana harga, diskon atau pajak diubah.
Dari binding di atas, harga, diskon, dan pajak saling tergantung satu sama lain (dependencies), dan
bisa dikatakan bahwa hargaJual terikat dengan harga, diskon, dan pajak.
Agar binding bekerja dengan benar, maka perlu bahwa binding diberi tahu setiap dependensinya
berubah. Bahasa pemrograman yang mendukung binding memberikan mekanisme untuk
meregistrasi listener ke dependensi. Sehingga ketika dependensi menjadi salah atau berubah,
semua listener akan memberi tahu. Sebuah binding bisa menyinkronkan dirinya sendiri dengan
dependensinya ketika menerima pemberitahuan.
Sebuah binding bisa termasuk ke dalam eager binding atau lazy binding. Pada eager binding,
variabel yang terikat menghitung ulang segera setelah ada perubahan dependensinya. Pada lazy
binding, variabel yang terikat tidak menghitung ulang setelah ada perubahan dependensinya.
Perhitungan ulangnya akan dibaca di lain waktu. Lazy binding bekerja lebih baik dibandingkan
eager binding.
Sebuah binding bisa termasuk kedalam unidirectional atau bidirectional. Binding unidirectional
hanya bekerja di satu arah; perubahan pada dependensinya disebarkan ke variabel terikat.
Bidirectional binding bekerja pada dua arah. Dimana antara variabel terikat dan dependensinya
menjaga nilainya tetap tersinkronisasi satu dengan lainnya. Cirinya adalah, bidirectional binding
hanya didefinisikan antara dua variabel, contohnya; x = y dan y = x, dimana nilai x dan y selalu
sama.
Secara matematika, tidak mungkin mendefinisikan sebuah bidirectional binding dengan banyak
variabel unik. Pada contoh di atas, ikatan pada harga jual termasuk dalam unidirectional binding.
Jika kita ingin membuatnya menjadi bidirectional binding, tidak memungkinkan untuk
menghitung nilai dari daftar harga, diskon, dan pajak ketika harga jual diubah.
Aplikasi GUI memberi penggunak dengan UI widget, sebagai contoh, text field, check box, dan
button untuk manipulasi data. Data yang ditampilkan di UI widget bisa disinkronkan berdasarkan
model data. Di sini, bidirectional binding diperlukan agar UI dan model data bisa sinkron.

Memahami dukungan Binding (Ikatan) di JavaBeans

Sebelum kita membicarakan properti dan ikatan pada javaFX, marilah kita memahami terlebih
dahulu tentang ikatan pada JavaBeans API. Jika sebelumnya telah familiar dengan JavaBeans API,
bisa melanjutkan ke bahasan berikutnya.
Java telah mendukung ikatan/binding untuk properti bean sejak pertama kali rilis. Listing 2-1 di
bawah ini menampilkan sebuah bean Karyawan dengan properti nama dan gaji.
Listing 2- 1 JavaBean Karyawan dengan properti nama dan gaji

Kedua properti dari bean Karyawan bersifat read/write. Properti gaji merupakan properti ikatan
(bound). Di mana setter akan menghasilkan pemberitahuan perubahan properti ketika properti
gaji diubah.
Listener bisa didaftarkan atau dikeluarkan dari daftar sebagai pemberitahuan perubahan
menggunakan method addPropertyChangeListener() dan
removePropertyChangeListener(). Kelas PropertyChangeSupport adalah bagian dari
JavaBean API yang memfasilitasi pendaftaran dan penghapusan properti change listener serta
menembakkan properti change notification (notifikasi perubahan).
Tiap pihak yang berkepentingan dalam sinkronisasi nilai berdasarkan perubahan gaji perlu
mendaftar dengan bean Karyawan dan perlu melakukan tindakan ketika diberitahukan tentang
perubahannya.
Listing 2-2 menampilkan bagaimana mendaftar untuk memberitahukan perubahan gaji pada bean
Karyawan. Hasil keluaran(output) akan menampilkan pemberitahuan perubahan gaji sebanyak
dua kali, padahal method setSalary() dipanggil sebanyak tiga kali. Hal ini dikarenakan pada
pemanggilan method setSalary() yang kedua, nilai gaji sama dengan pada pemanggilan yang
pertama dan kelas PropertyChangeSupport cukup cerdas mendeteksi hal ini. Contoh tersebut
juga menampilkan bagaimana kita akan mengikat(bound) variabel menggunakan JavaBeans API.
Pajak seorang karyawan dihitung berdasarkan persentase pajak. Pada JavaBeans API,
pemberitahuan perubahan properti digunakan untuk mengikat variabel.
Listing 2- 2 kelas DemoKaryawan yang mengetes bean Karyawan pada perubahan gaji

Memahami Properti di JavaFX

JavaFX mendukung properti, event, dan ikatan melalui properties dan binding API. Dukungan
properti pada javaFX adalah lompatan besar dari properti JavaBeans.
Semua properti di javaFX adalah tampak. Sehingga properti tersebut dapat diamati untuk
pembatalan dan nilai perubahannya. Properti dapat dibedakan menjadi dua yaitu yang bisa
baca/tulis(read/write) dan yang hanya baca(read-only). Seluruh properti baca/tulis mendukung
ikatan.
Di javaFX, properti dapat merepresentasikan sebuah nilai ataupun kumpulan nilai. Pada bab ini,
hanya akan dibahas properti dengan nilai tunggal. Untuk properti yang merepresentasikan
kumpulan nilai akan dibahas di bab 3.
Di javaFX, properti adalah objek. Di mana ada hirarki kelas properti pada setiap tipe properti.
Sebagai contoh, kelas IntegerProperty, DoubleProperty, dan StringProperty secara
berturut-turut adalah representasi dari tipe properti int, double, dan String. Kelas tersebut
adalah abstrak. Ada dua tipe untuk mengimplementasikannya: yang satu, merepresentasikan
properti baca/tulis, satu lagi merepresentasikan properti read-only (hanya bisa baca). Sebagai
contoh; kelas SimpleDoubleProperty dan ReadOnlyDoubleWrapper adalah kelas yang
secara nyata objeknya menggunakan properti double secara berturut-turut sebagai read/write dan
read-only.
Di bawah ini adalah contoh bagaimana membuat IntegerProperty dengan nilai awal 100.
IntegerProperty counter = new SimpleIntegerProperty(100);

Properti memberikan dua pasang method getter dan setter: get()/set() and getValue()/
setValue(). Method get()dan set() untuk mendapatkan (get) dan menetapkan (set) nilai
pada properti. Untuk properti primitif, maka bekerja dengan nilai bertipe primitif juga. Sebagai
contoh, pada IntegerProperty, tipe yang dikembalikan pada method get() dan tipe
parameter pada method set() adalah int. Method getValue() and setValue() bekerja
dengan tipe objek/referensi. Contohnya, tipe kembalian dan tipe parameter adalah Integer pada
IntegerProperty.

Perhatikan potongan kode berikut yang menggunakan sebuah IntegerProperty dengan

methodnya get()dan set(). Properti counter adalah termasuk properti read/write yang
merupakan objek dari kelas SimpleIntegerProperty.
IntegerProperty counter = new SimpleIntegerProperty(1);
int counterValue = counter.get();
System.out.println("Counter:" + counterValue);

counter.set(2);
counterValue = counter.get();
System.out.println("Counter:" + counterValue);
 Counter:1
Counter:2

Bekerja dengan properti read-only sedikit lebih rumit. Sebuah kelas ReadOnlyXXXWrapper
memiliki dua properti dengan tipe XXX: yang satu read-only dan satunya lagi read/write. Kedua
properti tersebut tersinkronisasi. Di mana method-nya getReadOnlyProperty()
mengembalikan sebuah objek ReadOnlyXXXProperty.
Perhatikan potongan kode di bawah ini yang menampilkan cara membuat properti Integer
read-only. Properti idWrapper adalah read/write, sedangkan properti id adalah read-only.
Ketika nilai dari properti idWrapper diubah, maka nilai pada id juga berubah otomatis.
ReadOnlyIntegerWrapper idWrapper = new ReadOnlyIntegerWrapper(100);
ReadOnlyIntegerProperty id = idWrapper.getReadOnlyProperty();

System.out.println("idWrapper:" + idWrapper.get());
System.out.println("id:" + id.get());

// Change the value

idWrapper.set(101);

System.out.println("idWrapper:" + idWrapper.get());
System.out.println("id:" + id.get());

idWrapper:100
id:100
idWrapper:101
id:101