Kotak Dialog ColorDialog

Kotak dialog ColorDialog digunakan untuk memilih warna, misalnya digunakan untuk memilih warna huruf, latar belakang kanvas, dan lain sebagainya.

Kotak dialog ini tidak memiliki bit gaya atau event. Keluarannya bertipe RGB yang merupakan representasi dari gabungan warna Red Green Blue yang tidak bergantung pada suatu device. Kelas RGB tersedia dalam paket org.eclipse.swt.graphics
Untuk menggunakannya sama seperti pada kotak-kotak dialog lainnya.
Berikut ini adalah beberapa metode yang terdapat pada kelas ColorDialog

Metode	Penjelasan
open()	Membuka kotak dialog untuk dipresentasikan kepada user Mengembalikan RGB yang merupakan warna yang dipilih user. Jika tidak ada warna yang dipilih atau tombol Cancel ditekan, akan mengembalikan null.
getRGB()	Mengembalikan RGB warna yang dipilih user.
setRGB(RGB warna)	Mengeset warna RGB awal ketika kotak dialog dipresentasikan kepada user

"Membuat Program JAVA dengan Menggunakan Array"

Jika sekumpulan data digabungkan dalam satu unit, hasilnya adalah suatu struktur data. Data struktur dapat berupa struktur yang sangat kompleks, akan tetapi dalam banyak aplikasi, data struktur yang cocok hanya terdiri dari kumpulan data berurutan. Struktur data sederhana seperti ini bisa berupa array atau record.
Istilah "record" sebetulnya tidak digunakan pada Java. Suatu record pada intinya mirip dengan objek pada Java yang hanya memiliki variabel instansi tanpa metode instansi. Beberapa bahasa pemrograman lain yang tidak mendukung objek biasanya mendukung record. Dalam bahasa C yang bukan bahasa berorientasi objek, misalnya, memiliki tipe data record, dimana pada C disebut "struct". Data pada record -- dalam Java, adalah variabel instansi suatu objek -- disebut field suatu record. Masing-masing item disebut nama field. Dalam Java, nama field adalah nama variabel instansi. Perbedaan sifat dari suatu record adalah bahwa item pada record dipanggil berdasarkan namanya, dan field yang berbeda dapat berupa tipe yang berbeda. Misalnya, kelas Orang didefisikan sebagai :

class Orang {
    String nama;
    int nomorID;
    Date tanggalLahir;
    int umur;
}

maka objek dari kelas Orang bisa disebut juga sebagai record dengan 4 field. Nama fieldnya adalah nama, nomorID, tanggalLahir dan umur. Lihat bahwa tipe datanya berbeda-beda yaitu String, int, dan Date.
Karena record hanya merupakan bagian lebih kecil dari objek, kita tidak akan bahas lebih lanjut di sini.
Seperti record, suatu array adalah kumpulan item. Akan tetapi, item pada record dipanggil dengan nama, sedangkan item pada array dinomori, dan masing-masing item dipanggil besarkan nomor posisi pada array tersebut. Semua item pada array harus bertipe sama. Definisi suatu array adalah : kumpulan item bernomor yang semuanya bertipe sama. Jumlah item dalam suatu array disebut panjang array. Nomor posisi dari array disebut indeks item tersebut dalam array. Tipe dari item tersebut disebut tipe dasar dari array.
Tipe dasar suatu array bisa berupa tipe Java apa saja, baik berupa tipe primitif, nama kelas, atau nama interface. Jika tipe dasar suatu array adalah int, maka array tersebut disebut "array int". Suatu array bertipe String disebut "array String". Akan tetapi array bukan urutan int atau urutan String atau urutan nilai bertipe apapun. Lebih baik jika array adalah urutan variabel bertipe int atau String atau tipe lainnya.
Seperti biasa, ada dua kemungkinan kegunaan variabel : sebagai nama suatu lokasi di memori, dan nama suatu nilai yang disimpan pada lokasi memori. Setiap posisi pada array bersifat seperti variabel. Setiap posisi dapat menyimpan nilai dengan tipe tertentu (yaitu tipe dasar array). Isinya bisa diganti kapanpun. Nilai tersebut disimpan di dalam array. Array merupakan kontainer bukan kumpulan nilai.
Item pada array (maksudnya setiap anggota variabel dalam array tersebut) sering juga disebut elemen array. Dalam Java, elemen array selalu dinomori mulai dari nol. Yaitu, indeks dari elemen pertama suatu array adalah nol. Jika panjang array adalah N, maka indeks elemen terakhir adalah N-1. Sekali array dibuat, maka panjangnya tidak bisa diubah lagi.
Dalam Java, array adalah objek. Ada beberapa konsekuensi yang lahir dari fakta ini. Array harus dibuat dengan operator new. Variabel tidak bisa menyimpan array; variabel hanya bisa merujuk pada array. Variabel lain yang bisa merujuk array juga bisa bernilai null yang berarti ia tidak merujuk pada lokasi memori apapun. Seperti objek lain, array juga bagian dari suatu kelas, di mana seperti kelas lain adalah kelas turunan dari kelas Object. Elemen array pada dasarnya adalah variabel instansi dalam objek array, kecuali mereka dipanggil dalam indeksnya bukan namanya.
Meskipun array berupa objek, ada beberapa perbedaan antara array dan objek lainnya, dan ada beberapa fitur khusus Java untuk membuat dan menggunakan array.

---

Misalnya A adalah variabel yang merujuk pada suatu array. Maka indeks k di dalam A bisa dipanggil dengan A[k]. Item pertama adalah A[0], yang kedua adalah A[i], dan seterusnya. A[k] adalah suatu variabel dan bisa digunakan seperti variabel lainnya. Kita bisa memberinya nilai, bisa menggunakannya dalam ekspresi, dan bisa diberikan sebagai parameter pada subrutin. Semuanya akan didiskusikan di bawah nanti. Untuk sekarang ingat sintaks berikut

variabel_array [ekspresi_integer]

untuk merujuk pada suatu array.
Meskipun setiap array merupakan suatu objek, kelas array tidak harus didefinisikan sebelumnya. Jika suatu tipe telah ada, maka kelas array dari tipe tersebut otomatis ada. Jika nama suatu tipe adalah TipeDasar, maka nama kelas arraynya adalah TipeDasar[]. Artinya, suatu objek yang diciptakan dari kelas TipeDasar[] adalah array dari item yang tiap itemnya bertipe TipeDasar. Tanda kurung "[]" dimaksudkan untuk mengingat sintaks untuk mengambil item di dalam suatu array. "TipeDasar[]" dibaca seperti "array TipeDasar". Mungkin perlu juga dijelaskan bahwa jika KelasA adalah kelas turunan dari KelasB maka KelasA[] otomatis menjadi kelas turunan KelasB[].
Tipe dasar suatu array dapat berupa tipe apapun yang ada atau sudah didefinisikan pada Java. Misalnya tipe primitif int akan diturunkan kelas array int[]. Setiap elemen di dalam array int[] adalah variabel yang memiliki tipe int dan bisa diisi dengan nilai dengan tipe int. Dari kelas yang bernama String diturunkan tipe array String[]. Setiap elemen di dalam array String[] adalah variabel dengan tipe String, yang bisa diisi dengan nilai bertipe String. Nilai ini bisa null atau referensi ke objek yang bertipe String (dan juga kelas turunan dari String)
Mari kita lihat contoh lebih konkrotnya menggunakan array bilangan bulat sebagai contoh pertama kita. Karena int[] adalah sebuah kelas, maka kita bisa menggunakannya untuk mendeklarasikan variabel. Misalnya,

int[] daftar;

yang membuat variabel bernama daftar dengan tipe int[]. Variabel ini bisa menunjuk pada array int, akan tetapi nilai awalnya adalah null (jika merupakan variabel anggota suatu kelas) atau tak tentu (jika merupakan variabel lokal di dalam suatu metode). Operator new digunakan untuk membuat objek array baru, ayng kemudian bisa diberikan kepada daftar. Sintaksnya sama seperti sintaks sebelumnya, yaitu :

daftar = new int[5];

membuat array 5 buah integer. Lebih umum lagi, konstruktor "new TipeDasar[N]" digunakan untuk membuat array bertipe TipeDasar[]. Nilai N di dalam kurung menyatakan panjang array, atau jumlah elemen yang bisa ditampung. Panjang array adalah variabel instansi di dalam objek array, sehingga array tahu berapa panjangnya. Kita bisa mendapatkan panjang suatu array, misalnya daftar menggunakan daftar.length (akan tetapi kita tidak bisa mengubahnya)
Hasil dari pernyataan "daftar = new int[5];" dapat diilustrasikan sebagai berikut

Perlu dicatat bahwa array integer secara otomatis diisi dengan nol. Dalam Java, array yang baru dibuat akan selalu diisi dengan nilai tertentu: nol untuk angka, false untuk boolean, karakter dengan nilai Unicode 0 untuk char dan null untuk objek.
Elemen di dalam array daftar dapat dirujuk dengan daftar[0], daftar[1], daftar[2], daftar[3], dan daftar[4] (ingat juga bahwa nilai indeks terbesar adalah panjangnya array dikurang satu). Akan tetapi, referensi array sebetulnya lebih umum lagi. Tanda kurung di dalam referensi array bisa berisi ekspresi apapun yang nilainya suatu integer. Misalnya jika idks adalah variabel bertipe int, maka daftar[idks] dan daftar[2*idks+3] secara sintaks benar.
Contoh berikut akan mencetak semua isi integer di dalam array daftar ke layar :

for (int i = 0; i < daftar.length; i++) {
    System.out.println( daftar[i] );
}

Perulangan pertama adalah ketika i = 0, dan daftar[i] merujuk pada daftar[0]. Jadi nilai yang disimpan pada variabel daftar[0] akan dicetak ke layar. Perulangan kedua adalah i = 1, sehingga nilai daftar[i] dicetak. Perulangan berhenti setelah mencetak daftar[4] dan i menjadi sama dengan 5, sehingga kondisi lanjutan "i < daftar.length" tidak lagi benar. Ini adalah contoh umum dari menggunakan perulangan untuk mengolah suatu array.
Penggunaan suatu variabel dalam suatu program menyatakan lokasi di memori. Pikirkan sesaat tentang apa yang akan komputer lakukan ketika ia menemukan referensi ke elemen suatu array daftar[k] ketika program berjalan. Komputer harus menentukan lokasi memori di mana ia dijadikan referensi. Untuk komputer, daftar[k] berarti : "Ambil pointer yang disimpan di dalam variabel daftar. Ikuti pointer ini untuk mencari objek array. Ambil nilai k. Pergi ke posisi ke-k dari array tersebut, dan di sanalah alamat memori yang Anda ingin."
Ada dua hal yang bisa salah di sini. Misalnya nilai daftar adalah null. Dalam kasus ini, maka daftar tidak memiliki referensi sama sekali. Percobaan merujuk suatu elemen pada suatu array kosong adalah suatu kesalahan. Kasus ini akan menampilkan pesan kesalahan "pointer kosong". Kemungkinan kesalahan kedua adalah jika daftar merujuk pada suatu array, akan tetapi k berada di luar rentang indeks yang legal. Ini akan terjadi jika k < 0 atau jika k >= daftar.length. Kasus ini disebut kesalahan "indeks array keluar batas". Ketika kita menggunakan array dalam program, kita harus selalu ingat bahwa kedua kesalahan tersebut mungkin terjadi. Dari kedua kasus di atas, kesalahan indeks array keluar batas adalah kesalahan yang lebih sering terjadi.

---

Untuk suatu variabel array, seperti variabel lainnya, kita bisa mendeklarasikan dan mengisinya dengan satu langkah sekaligus, misalnya :

int[] daftar = new int[5];

Jika daftar merupakan variabel lokal dalam subrutin, maka perintah di atas akan persis sama dengan dua perintah :

int[] daftar;
daftar = new int[5];

(Jika daftar adalah variabel instansi, tentukan kita tidak bisa mengganti "int[] daftar = new int[5];" dengan "int[] daftar; daftar = new int[5];" karena ini hanya bisa dilakukan di dalam subrutin)
Array yang baru dibuat akan diisi dengan nilai awal yang tergantung dari tipe dasar array tersebut seperti dijelaskan sebelumnya. Akan tetapi Java juga menyediakan cara untuk memberi isi array baru dengan daftar isinya. Dalam pernyataan yang untuk membuat array, ini bisa dilakukan dengan menggunakan penginisialiasi array (array initializer), misalny :
int[] daftar = { 1, 4, 9, 16, 25, 36, 49 }; akan membuat array baru yang berisi 7 nilai, yaitu 1, 4, 9, 16, 25, 36, dan 49, dan mengisi daftar dengan referensi ke array baru tersebut. Nilai daftar[0] berisi 1, nilai daftar[1] berisi 4, dan seterusnya. Panjang daftar adalah 7, karena kita memberikan 7 nilai awal kepada array ini.
Suatu penginisialisasi array memiliki bentuk daftar angka yang dipisahkan dengan koma dan diapit dengan tanda kurung kurawal {}. Panjang array tersebut tidak perlu diberikan, karena secara implisit sudah bisa ditentukan dari jumlah daftar angkanya. Elemen di dalam penginisialisasi array tidak harus selalu berbentuk konstanta. Juga bisa merupakan variabel atau ekspresi apa saja, asalkan nilainya bertipe sama dengan tipe dasar array tersebut. Misalnya, deklarasi berikut membuat array dari delapan jenis Color beberapa warna telah dibentuk dengan ekspresi "new Color(r,g,b);"

Color[] palette =
{
    Color.black,
    Color.red,
    Color.pink,
    new Color(0,180,0),  // hijau gelap
    Color.green,
    Color.blue,
    new Color(180,180,255),  // biru muda
    Color.white
};

Inisialisasi array bentuk seperti ini hanya bisa digunakan dalam deklarasi suatu variabel baru, akan tetapi tidak bisa digunakan seperti operator pemberi nilai (=) di tengah-tengah suatu program. Akan tetapi ada cara lain yang bisa digunakan sebagai pernyataan pemberian nilai atau diberikan ke dalam subrutin. Yaitu menggunakan jenis lain dari operator new untuk membuat atau menginisialisasi objek array baru. (Cara ini agak kaku dengan sintaks aneh, seperti halnya sintaks kelas anonim yang telah didiskusikan sebelumnya). Misalnya untuk memberi nilai kepada suatu variabel daftar, kita bisa menggunakan :

daftar = new int[] { 1, 8, 27, 64, 125, 216, 343 };

Sintaks umum dari bentuk operator new seperti ini adalah

new TipeDasar [ ] { daftar_nilai_nilai }

Ini adalah suatu ekspresi yang isinya merupakan objek, dan bisa digunakan untuk banyak situasi di mana suatu objek dengan tipe TipeDasar dipentingkan. Misalnya buatTombol merupakan metode yang mengambil array String sebagai parameter, maka kita bisa menuliskan
buatTombol( new String[] { "Stop", "Jalan", "Berikut", "Sebelum" } );Catatan terakhir : untuk alasan sejarah, maka deklarasi

int[] daftar;

akan bernilai sama dengan

int daftar[];

di mana sintaks tersebut digunakan dalam bahasa C dan C++. Akan tetapi sintaks alternatif ini tidak begitu masuk akan dalam Java, atau mungkin lebih baik dihindari. Lagian, maksudnya adalah mendeklarasikan variabel dengan tipe tertentu dan namanya adalah int[]. Akan lebih masuk akan untuk mengikuti siintaks "nama_tipe nama_variabel" seperti pada bentuk bertama.

Button (Tombol) pada java

"Button (Tombol)"

Kelas Button melambangkan suatu tombol yang jika ditekan atau dilepaskan akan melepaskan event tertentu.
Kelas Button memiliki beberapa bit gaya :

Bit gaya	Tampilan (pada Linux)	Keterangan
SWT.ARROW		Hanya salah satu dari gaya ini yang boleh digunakan
SWT.CHECK
SWT.PUSH
SWT.RADIO
SWT.TOGGLE
SWT.FLAT		Menampilkan tombol dengan tampilan "rata", bukan seperti tombol biasa yang memiliki tampilan 3D seperti tombol tekan. (Hanya untuk beberapa platform tertentu saja)
SWT.LEFT		Hanya salah satu dari gaya ini yang boleh digunakan
SWT.RIGHT
SWT.CENTER
SWT.UP		Hanya boleh digunakan bersama dengan SWT.ARROW
SWT.DOWN
SWT.LEFT
SWT.RIGHT

Suatu tombol bisa diisi teks atau gambar, tapi tidak keduanya secara bersamaan. Teks yang diisi pada suatu tombol tidak dapat berisi baris baru '\n' atau '\r'. Berikut ini adalah beberapa metode yang digunakan untuk mengeset dan mengambil teks dan gambar pada tombol.

Metode	Penjelasan
setText(String teks)	Mengeset teks pada tombol
getText()	Mengembalikan String yang merupakan teks pada tombol
setImage(Image image)	Mengeset gambar pada tombol
getImage()	Mengembalikan Image yang merupakan gambar pada tombol

Berikut ini adalah contoh mengeset teks dan gambar pada suatu tombol :

Button tombolTeks = new Button(shell, SWT.PUSH);
tombolTeks.setText("Tombolku");
 
ImageData dataGambar = new ImageData("c:\\grafik.bmp");
Image gambar = new Image(display, dataGambar);
Button tombolGambar = new Button(shell, SWT.PUSH);
tombolGambar.setImage(gambar);

Kita juga bisa mengatur kerapatan (alignment) suatu teks atau gambar. Selain menggunakan bit gaya SWT.LEFT, SWT.RIGHT, atau SWT.CENTER pada konstruktor. Atau kita juga bisa menggunakan metode instansi pada kelas tombol berikut :

Metode	Penjelasan
setAlignment(int rapatan)	Mengeset kerapatan suatu teks atau gambar, rapatan hanya bisa berisi SWT.LEFT, SWT.RIGHT, atau SWT.CENTER
getAlignment()	Mengambil int yang merupakan rapatan suatu teks atau gambar pada tombol.

Misalnya,

Button tombolTeks = new Button(shell, SWT.PUSH);
tombolTeks.setText("Tombolku");
tombolTeks.setAlignment(SWT.LEFT);

Tombol SWT.PUSH
Tombol ini memiliki sifat tombol biasa, yaitu ketika di klik tombol akan tampil seperti ditekan, dan ketika dilepas maka tombol akan kembali seperti biasa. Tombol ini memiliki event berikut :

Kelas Event (event bertipe)	Interface/Kelas Listener (listener bertipe)	Metode (listener bertipe)	Jenis event (event tanpa tipe)	Penjelasan
SelectionEvent	SelectionListener (dan SelectionAdapter)	widgetDefaultSelected(SelectionEvent)	SWT.DefaultSelection	Suatu aksi pemilihan dilakukan pada pilihan default (misalnya ketika tombol Enter ditekan)
		widgetSelected(SelectionEvent)	SWT.Selection	Suatu aksi pemilihan dilakukan dalam widget (misalnya memilih item pada drop down list

Misalnya untuk menambahkan listener untuk event yang terjadi ketika tombol ditekan, kita bisa menggunakan SWT.Selection, misalnya pada contoh berikut :

        Button tombolTeks = new Button(shell, SWT.PUSH);
        tombolTeks.setText("Tombolku");
        tombolTeks.addSelectionListener(new SelectionAdapter() {
        	public void widgetSelected(SelectionEvent e) {
        		// Perintah-perintah lainnya
        	}
        });

Tombol SWT.ARROW
Tombol ini secara perilaku mirip dengan SWT.PUSH, akan tetapi perbedaannya tombol ini tidak bisa diisi teks atau gambar. Tombol ini akan menggambar tanda panah, yang arahnya tergantung dari bit gaya yang diberikan, bisa ke kiri, kanan, atas atau bawah.
Tombol SWT.TOGGLE
Berbeda dengan tombol SWT.PUSH, tombol ini ketika diklik akan berada dalam posisi tertekan terus walaupun mouse sudah dilepaskan. Untuk mengembalikannya, tombol ini harus diklik kembali. Karena tombol ini bisa memiliki dua keadaan, yaitu keadaan tertekan dan keadaan terlepas, ada dua metode yang kita bisa gunakan untuk mengeset keadaan tombol atau untuk mengambil keadaan tombol saat itu, yaitu

Metode	Penjelasan
setSelection(boolean pilih)	Mengeset keadaan suatu tombol. Jika pilih bernilai true, maka tombol berada dalam keadaan tertekan.</td></tr><tr><td>getSelection()</td><td>Mengembalikan [code]boolean yang berisi keadaan suatu tombol apakah dalam keadaan tertekan atau terlepas

Tombol SWT.CHECK
Tombol SWT.CHECK tidak berbentuk seperti tombol, akan tetapi perilakunya mirip dengan SWT.TOGGLE. Secara tampilan, SWT.CHECK ditampilkan seperti tombol kotak tik, yang apabila diklik kotak tik akan tercontreng. Untuk menghilangkan contrengan, klik kembali kotak cek tersebut.
Karenanya, mirip seperti SWT.TOGGLE, tombol ini memiliki dua keadaan tetap, yaitu kondisi tercontreng dan tidak tercontreng. Untuk mengeset keadaan ini, gunakan metode yang sama dengan SWT.TOGGLE, yaitu setSelection() dan getSelection().
Tombol SWT.RADIO
Tombol ini mirip seperti SWT.CHECK, di mana apabila kita mengklik tombol radio, maka tombol tersebut berada dalam keadaan terpilih. Perbedaannya, jika beberapa tombol SWT.RADIO berada dalam satu induk, maka hanya satu tombol radio saja yang bisa aktif. Artinya jika kita mengklik tombol radio kedua, maka tombol ini akan terpilih dan yang lainnya akan mati. Untuk mengesetnya, gunakan metode yang sama seperti pada SWT.CHECK dan SWT.TOGGLE.
Biasanya, hanya satu tombol radio pada suatu kotak dialog atau jendela tidak masuk akal. Karena hanya ada tombol radio yang bisa aktif, maka satu tombol radio ini akan selalu aktif, sehingga percuma untuk diletakkan dalam GUI. Jika ada dua tombol radio, perilakunya persis sama dengan satu tombol SWT.CHECK (jika satu aktif, maka yang lainnya pasti tidak aktif). Untuk itu tombol radio biasanya digunakan untuk meminta user memilih satu dari sekian banyak pilihan.
Berikut ini adalah contoh program yang bisa Anda unduh di sini. Program ini akan menggambar beberapa jenis tombol. Jika salah satu tombol ditekan, maka warna latar belakang jendela akan berubah-ubah. Warna-warna ini disimpan dalam palette warna dalam bentuk array. Jika warna terakhir sudah ditampilkan, kemudian tombol ditekan kembali, maka warna pertama akan ditampilkan kembali.

package com.lyracc.tombolwarna;
 
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.events.*;
 
public class TombolWarna {
 
	// Variabel-variabel widget kita deklarasikan sebagai
	// variabel privat
	private Display display;
	private Shell shell;
	private Color[] warna;
	private int warnaSekarang = 0;
	final int JUMLAHWARNA = 10;
 
	// Konstruktor kelas ini, untuk menginisialisasi semua widget
	TombolWarna() {
		// Membuat display dan shell baru
		display = new Display();
		shell = new Shell(display);
		shell.setLayout(new RowLayout());
 
		// Ubah ukuran jendela menjadi 200 x 200 piksel
		shell.setSize(250, 200);
 
		// Inisialisasi tombol-tombol
		Button tombol = new Button(shell,SWT.PUSH);
		tombol.setText("Tombolku SWT.PUSH");
 
		Button tombol1 = new Button(shell,SWT.ARROW | SWT.LEFT);
 
		Button tombol2 = new Button(shell,SWT.TOGGLE);
		tombol2.setText("Tombolku SWT.TOGGLE");
 
		Button tombol3 = new Button(shell,SWT.CHECK);
		tombol3.setText("Tombolku SWT.CHECK");
 
		Button tombol4 = new Button(shell,SWT.RADIO);
		tombol4.setText("Tombolku SWT.RADIO");
 
		// Mengeset event
		ListenerTombolWarna listenerTombolWarna = new ListenerTombolWarna();
		tombol.addSelectionListener(listenerTombolWarna);
		tombol1.addSelectionListener(listenerTombolWarna);
		tombol2.addSelectionListener(listenerTombolWarna);
		tombol3.addSelectionListener(listenerTombolWarna);
		tombol4.addSelectionListener(listenerTombolWarna);
 
		// Mengeset warna-warna
		warna = new Color[JUMLAHWARNA];
		warna[0] = display.getSystemColor(SWT.COLOR_BLACK);
		warna[1] = display.getSystemColor(SWT.COLOR_BLUE);
		warna[2] = display.getSystemColor(SWT.COLOR_CYAN);
		warna[3] = display.getSystemColor(SWT.COLOR_GRAY);
		warna[4] = display.getSystemColor(SWT.COLOR_GREEN);
		warna[5] = display.getSystemColor(SWT.COLOR_MAGENTA);
		warna[6] = display.getSystemColor(SWT.COLOR_RED);
		warna[7] = display.getSystemColor(SWT.COLOR_WHITE);
		warna[8] = display.getSystemColor(SWT.COLOR_YELLOW);
		warna[9] = display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
	}
 
	// Kelas listener ketika tombol ditekan
	class ListenerTombolWarna extends SelectionAdapter {
		public void widgetSelected(SelectionEvent e) {
			// Jika warna lebih sudah di akhir array
			// kembali ke warna 0
			if (warnaSekarang == warna.length)
				warnaSekarang = 0;
			shell.setBackground(warna[warnaSekarang++]);
		}		
	}
 
	// Perintah "standar" SWT, harus ada pada setiap aplikasi SWT
	public void run() {
		shell.open();
		while (!shell.isDisposed())
			if (!display.readAndDispatch()) 
				display.sleep();
		display.dispose();
	}
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// Instansiasi kelas ini, kemudian jalankan run
		TombolWarna tombolWarna = new TombolWarna();
		tombolWarna.run();
	}
}

"Konstruktor dan Inisialisasi Objek"

Kelas pada Java memiliki sifat yang sama sekali berbeda dengan tipe data primitif lainnya, seperti int atau boolean. Seperti disebutkan pada bagian sebelumnya, mendeklarasikan suatu variabel dengan tipe suatu kelas tidak berarti membuat objek dari kelas tersebut. Objek tersebut harus dibuat (constructed). Pada saat objek dibuat, komputer akan mencari tempat yang tidak dipakai pada memori heap untuk menempatkan objek tersebut, kemudian mengisi objek itu dengan variabel instansi. Sebagai programmer, kita tidak peduli dengan bagaimana suatu objek disimpan, akan tetapi kita ingin mengatur supaya nilai yang disimpan pada saat objek tersebut dibuat sesuai dengan keinginan kita. Dalam beberapa kasus, kita bahkan ingin suatu objek melakukan tugas tertentu untuk pertama kali begitu ia diciptakan.
Variabel instansi dapat diisi dengan nilai awal pada saat ia dideklarasikan, seperti variabel lainnya. Misalnya, kelas berikut yang bernama PasanganDadu, yang melambangkan sepasang dadu. Kelas ini memiliki dua variabel instansi yang melambangkan nilai yang ditunjukkan oleh masing-masing dadu dan metode instansi untuk mengocok dadu, yaitu :

class PasanganDadu {
    public int dadu1 = 3; // Angka pada dadu pertama
    public int dadu2 = 4; // Angka pada dadu kedua
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int)(Math.random()*6) + 1;
        dadu2 = (int)(Math.random()*6) + 1;
    }
} // akhir kelas PasanganDadu

Variabel instansi dadu1 dan dadu2 diisi dengan nilai awal 3 dan 4. Inisialisasi ini dilakukan setiap kali objek PasanganDadu dibuat. Ingat bahwa kelas PasanganDadu hanya 1, akan tetapi kita bisa membuat banyak objek dari kelas ini. Setiap kali objek dibuat, objek tersebut memiliki tempat di memori sendiri, yang disebut dengan instansi objek tersebut. Perintah "dadu1 = 3" dan "dadu2 = 4" akan dieksekusi setiap kali objek dibuat.
Kita bisa memodifikasi kelas PasanganDadu dengan nilai awal acak, bukan 3 dan 4 misalnya, dengan potongan kode berikut :

class PasanganDadu {
    public int dadu1 = (int)(Math.random()*6) + 1; // Angka pada dadu pertama
    public int dadu2 = (int)(Math.random()*6) + 1; // Angka pada dadu kedua
 
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int)(Math.random()*6) + 1;
        dadu2 = (int)(Math.random()*6) + 1;
    }
} // akhir kelas PasanganDadu

Karena inisialisasi dilakukan setiap kali objek dibuat, maka setiap objek akan memiliki nilai yang berbeda-beda hasil dari instruksi Math.random() pada inisialisasi variabel instansi. Untuk inisialisasi variabel static, hal ini tidak mungkin dilakukan, karena hanya ada 1 variabel statik untuk 1 kelas, tidak peduli berapa pun banyaknya objek yang dibuat.
Jika variabel instansi tidak kita beri nilai awal, maka nilai bawaan akan diberikan secara otomatis. Tipe data numerik (int, double, dll) memiliki nilai bawaan 0; boolean bernilai awal false; dan char bernilai awal karakter dengan kode Unicode 0. Variabel instansi juga bisa bertipe suatu objek. Dalam hal ini, variabel tersebut bernilai awal null. (Ingat bahwa String adalah objek, sehingga nilai awalnya adalah null).
Objek dibuat dengan operator new, misalnya program yang ingin menggunakan objek PasanganDadu dapat menggunakan perintah berikut :

// deklarasi variabel dan pembuatan objek dilakukan sekaligus
PasanganDadu dadu = new PasanganDadu();

Pada contoh di atas, new PasanganDadu() adalah perintah untuk membuat objek, meletakkannya di memori dan menyimpan alamat objek ini di memori pada variabel dadu. Bagian ekspresi PasanganDadu() mirip seperti memanggil subrutin. Sebetulnya itulah yang terjadi, yaitu program memanggil subrutin spesial yang dinamakan konstruktor (constructor). Mungkin Anda heran karena kita tidak melihat adanya subrutin bernama PasanganDadu(). Akan tetapi semua kelas memiliki konstruktor, yang jika kita tidak buat secara khusus, Java akan menambahkannya secara otomatis, yang disebut konstruktor bawaan.
Konstruktor bawaan melakukan hal-hal umum seperti mengalokasi memori, mengisi nilai variabel instansi dengan nilai bawaannya, dan mengembalikan alamat objek yang dibuat di memori. Jika kita menginginkan hal lain yang ikut dilaksanakan ketika suatu objek dibuat, maka kita harus membuat konstruktor sendiri.
Bagaimana cara mendefinisikan konstruktor? Konstruktor dideklarasikan mirip dengan deklarasi subrutin, dengan 3 perkecualian. Konstruktor tidak memiliki tipe keluaran (void pun tidak dibolehkan. Namanya harus sama dengan nama kelas di mana ia dideklarasikan. Sifat yang bisa digunakan hanya sifat akses, yaitu public, private, dan protected (static tidak diperbolehkan).
Di lain pihak, konstruktor memiliki blok yang terdiri dari kumpulan perintah seperti pada subrutin. Kita bisa menggunakan perintah apapun seperti pada subrutin biasa, termasuk memiliki satu atau lebih parameter formal. Sebetulnya salah satu alasan untuk menggunakan parameter adalah kita bisa membuat beberapa konstruktor yang menerima data dalam berbagai bentuk, sehingga objek yang kita buat bisa dinisialisasi dengan cara yang berbeda-beda sesuai dengan kondisi dan kebutuhan dari program yang akan kita buat.
Misalnya, kelas PasanganDadu di atas kita ubah sehingga kita bisa memberi nilai awal sendiri. Dalam hal ini kita buat konstruktor yang menerima 2 nilai sebagai nilai awal dadu, yaitu nilai1 dan nilai2.

class PasanganDadu {
    public int dadu1; // Angka pada dadu pertama
    public int dadu2; // Angka pada dadu kedua
 
    public PasanganDadu(int nilai1, int nilai2) {
        // Konstruktor, mengambil nilai1 dan nilai2 sebagai nilai awal untuk dadu1 dan dadu2
        dadu1 = nilai1;
        dadu2 = nilai2;
    }
 
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int)(Math.random()*6) + 1;
        dadu2 = (int)(Math.random()*6) + 1;
    }
} // akhir kelas PasanganDadu

Konstruktor dideklarasikan dalam bentuk "public PasanganDadu(int nilai1, int nilai2) ...", tanpa tipe keluaran dan dengan nama yang sama dengan nama kelas. Ini adalah cara Java mengenal suatu konstruktor dan membedakannya dengan subrutin biasa. Konstruktor ini memiliki 2 parameter yang harus diisi ketika konstruktor dipanggil. Misalnya,

PasanganDadu dadu = new PasanganDadu(1,2);

Membuat objek baru yang variabel intansinya dadu1 dan dadu2 bernilai 1 dan 2.
Karena sekarang kita telah membuat konstruktor, kita tidak bisa lagi membuat objek dengan perintah "new PasanganDadu()". Java akan membuat konstruktor bawaan apabila tidak ada satupun konstruktor yang didefinisikan. Akan tetapi, kita bisa membuat konstruktor lain di kelas tersebut, karena suatu kelas bisa terdiri dari beberapa konstruktor asalkan parameternya berbeda.
Sekarang kita akan modifikasi lagi kelas tersebut dengan 2 konstruktor, yang mana apabila tidak ada parameter yang diberikan, maka objek tersebut akan mengisi nilai dadu1 dan dadu2 dengan bilangan acak.

class PasanganDadu {
    public int dadu1; // Angka pada dadu pertama
    public int dadu2; // Angka pada dadu kedua
 
    public PasanganDadu() {
        // Isi dadu1 dan dadu2 dengan bilangan acak, dengan memanggil metode
        // kocok()
        kocok();
    }
 
    public PasanganDadu(int nilai1, int nilai2) {
        // Konstruktor, mengambil nilai1 dan nilai2 sebagai nilai awal untuk
        // dadu1 dan dadu2
        dadu1 = nilai1;
        dadu2 = nilai2;
    }
 
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int) (Math.random() * 6) + 1;
        dadu2 = (int) (Math.random() * 6) + 1;
    }
} // akhir kelas PasanganDadu

Sekarang kita bisa memilih bagaimana membuat objek, yaitu dengan "new PasanganDadu()" atau dengan "new PasanganDadu(x,y)", di mana x dan y adalah ekpresi bernilai int.
Kelas ini, bisa digunakan dalam program lain yang membutuhkan sepasang dadu. Program tersebut tidak lagi harus memanggil fungsi

(int)(Math.random()*6) + 1

karena perintah ini sudah diimplementasikan di dalam kelas PasanganDadu. Bagi programmer, teknik seperti ini mempermudah pemecahan masalah dengan mengelompokkannya menjadi ciri dan perilaku suatu objek.
Berikut ini adalah contoh program lain yang menggunakan objek PasanganDadu() untuk menghitung berapa kali kocok akan menghasilkan jumlah nilai yang sama. Program lengkapnya bisa diunduh di sini untuk diimport ke dalam Eclipse.

public class KocokDuaPasangDadu {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        PasanganDadu daduPertama = new PasanganDadu(); // pasangan dadu pertama
        PasanganDadu daduKedua = new PasanganDadu(); // pasangan dadu kedua
 
        int jumlahKocokan; // untuk mengitung berapa kali dua pasang dadu
                           // tersebut dikocok
        int total1; // hitung berapa kali dadu pertama muncul
        int total2; // hitung berapa kali dadu kedua muncul
 
        jumlahKocokan = 0;
        do {
            daduPertama.kocok(); // kocok dadu pertama
            total1 = daduPertama.dadu1 + daduPertama.dadu2; // hitung jumlahnya
            System.out.println("Pasangan dadu pertama berjumlah " + total1);
 
            daduKedua.kocok(); // kocok dadu pertama
            total2 = daduKedua.dadu1 + daduKedua.dadu2; // hitung jumlahnya
            System.out.println("Pasangan dadu pertama berjumlah " + total2);
 
            jumlahKocokan++;
            System.out.println(); // cetak baris kosong
 
        } while (total1 != total2);
 
        System.out.println("Butuh " + jumlahKocokan
                + " kocokan hingga pasangan "
                + " dadu pertama dan kedua berjumlah sama");
 
    }
}

Keluarannya adalah sebagai berikut

Konstruktor adalah subrutin, tetapi bukan subrutin biasa, dan bukan metode instansi, karena konstruktor tidak dimiliki oleh suatu objek. Karena tugasnya membuat objek, maka konstruktor dijalankan sebelum objek dibuat. Konstruktor mirip dengan subrutin anggota statik, tetapi dia tidak bisa dideklarasikan "static". Bahkan menurut spesifikasi Java, konstruktor bukan anggota suatu kelas sama sekali.
Tidak seperti subrutin lain, konstruktor hanya bisa dipanggil melalui operator "new", dalam bentuk

new nama_kelas(parameter);

di sini "parameter" boleh kosong. Hasil keluarannya adalah alamat memori di mana objek yang baru dibuat tersebut disimpan. Seringkali, kita akan simpan hasil keluarannya di dalam suatu variabel, atau bisa juga hasil keluarannya diberikan ke dalam suatu fungsi sebagai parameter.
Memanggil konstruktor lebih rumit daripada memanggil subrutin atau fungsi biasa. Hal-hal berikut sangat membantu untuk lebih memahami apa yang dilakukan oleh konstruktor ketika ia dipanggil untuk membuat suatu objek:

1. Pertama, komputer memberi daerah pada memori yang tidak digunakan, cukup untuk dipakai oleh objek yang akan dibuat
2. Komputer akan mengisi variabel instansi objek tersebut dengan nilai bawaannya. Jika deklarasi variabel instansi pada kelas memiliki nilai awal tertentu, maka nilai tersebut akan dimasukkan sebagai nilai awalnya.
3. Parameter aktual pada konstruktor (jika ada) akan dievaluasi dan nilainya diberikan kepada parameter formal konstruktor tersebut.
4. Perintah pada konstruktor (jika ada) akan dilaksanakan.
5. Referensi objek akan dikembalikan kepada si pemanggil.

Hasil keluarannya adalah referensi ke objek yang baru saja dibuat. Kita bisa gunakan referensi ini untuk mengambil data pada variabel instansi objek tersebut atau memanggil metode instansinya.
Contoh lain, mari kita ganti kelas Murid pada bagian sebelumnya. Kita akan tambahkan konstruktor dan juga kita ganti variabel instansi "nama" menjadi bersifat privat.

class Murid {
    private String nama;    // Nama murid
    public double nilai1, nilai2, nilai3;   // Nilai-nilai ujian
 
    Murid(String namaMurid) {
        // Konstruktor objek Murid
        nama = namaMurid;
    }
 
    public String getNama() {
        // Metode untuk mengambil variabel anggota yang bersifat private
        // misalnya variabel instansi nama
        return nama;
    }
 
    public double hitungRataRata() {
        // Hitung rata-rata ulangan
        return (nilai1 + nilai2 + nilai3) / 3;
    }
 
}  // akhir kelas Murid

Objek bertipe Murid berisi informasi tentang murid tertentu. Konstruktor kelas ini memiliki parameter bertipe String yaitu nama murid yang akan kita buat. Objek bertipe Murid ini bisa dibuat dengan pernyataan seperti:

mrd1 = new Murid("Ahmad Surahmat");
mrd2 = new Murid("Hamid Samsudin")

Pada versi aslinya, isi variabel nama harus diisi dengan perintah terpisah setelah objek dibuat. Masalahnya programmer tidak selalu ingat untuk mengisi nilai nama. Pada versi baru di atas, setiap kali kita membuat objek, parameter namaMurid harus disertakan, karena ini dideklarasikan pada konstruktornya. Dengan demikian potensi bug karena kelalaian programmer dapat dihilangkan dengan mudah.
Contoh keamanan lainnya adalah dengan membuat variabel instansi nama bersifat private. Ini berarti variabel ini tidak bisa diakses oleh dunia luar secara langsung. Variabel ini hanya bisa diambil nilainya dengan metode instansi getNama, dan karena tidak bisa diakses langsung dari luar, maka isi variabel ini tidak bisa diganti dari luar kelas. Sekali objek Murid dibuat, maka namanya tidak bisa diganti selama murid tersebut ada.