Pemrograman Berorientasi Objek

Class adalah struktur dasar dari pemrograman berorientasi objek yang mendefinisikan variable dan method-method pada seluruh objek tertentu. Class juga mendefinisikan tipe data baru untuk menciptakan model dari objek yang dibuat sesuai dengan tipe data baru tersebut. Dengan kata lain class menciptakan instant dari objek. class juga merupakan grup suatu object dengan kemiripan attributes/properties, behaviour dan relasi ke object lain.

Objek adalah instance dari class. Objek merupakan perangkat lunak yang berisi sekumpulan variable dan method-method terkait. Objek merupakan entitas yang memiliki keadaan, behaviour dan identitas yang tugasnya dirumuskan dalam suatu lingkup masalah dengan baik.

Instantiate adalah proses pembentukkan objek dari suatu class.

Instance Variable adalah variable yang ada di dalam class tetapi berada di luar method. Instance variable ini merupakan attribute dari suatu class dan mempunyai default value yang tidak perlu diinisialisasi.

Instance Method merupakan method yang hanya tersedia apabila instance dari suatu class dibuat.

Class Variable (Static Member Variables) adalah variable yang dimiliki oleh class yang dapat memiliki nilai yang sama untuk semua objek pada class yang sama dan dapat diakses oleh semua instance dari class.

Konstruktor adalah sebuah tipe khusus dari method yang digunakan untuk membuat dan menginisialisasi sebuah object baru. Konstruktor merupakan suatu method yang memiliki nama yang sama dengan nama classnya.

Mari kita bahas satu-persatu,
Objek, Metode Instansi dan Variable Instansi
Konstruktor dan Inisialisasi Objek
Pewarisan, Polimorfisme, dan Kelas Abstrak 
Variabel this dan super 
Interface, Class Bertingkat, dan Detail Lain

Read More

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.

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.

Read More

Objek, Metode Instansi dan Variable Instansi

Pemrograman berorientasi objek bermaksud untuk memecahkan masalah programming mirip dengan cara berfikir manusia dan bagaimana manusia berinteraksi dengan dunia. Kita telah melihat bagaimana masalah programming dipecahkan dengan membaginya menjadi instruksi-instruksi kecil yang dirangkai menjadi suatu kesatuan tugas. Cara ini disebut juga dengan pemrograman berdasarkan prosedur.

Pada pemrograman berorientasi objek, kita membagi masalah pemrograman berdasarkan objek atau "sesuatu" benda. Objek ini diibaratkan seperti makhluk hidup, yaitu memiliki ciri-ciri fisik dan juga perilaku. Dalam pemrograman berorientasi objek, ciri-ciri fisik ini disebut juga sebagai atribut, pada dasarnya berisi informasi tentang objek tersebut. Sedangkan perilaku disebut sebagai metode, yaitu bagaimana suatu objek bertindak atau melakukan sesuatu.

Dengan cara ini diharapkan pemrograman berorientasi objek merupakan pemrograman yang lebih alami dibandingkan dengan pemrograman berorientasi prosedur, karena cara fikir kita sudah terbiasa dengan bagaimana kita berinteraksi dengan dunia.

Sampai tingkat tertentu, PBO hanya merubah cara pandang programmer. Objek dalam kaitannya dengan dasar pemrograman adalah gabungan dari variabel (dalam hal ini atribut) dan subrutin (yaitu metode) yang berinteraksi dengan variabel pada objek.

Banyak bahasa pemrograman lain yang juga mendukung konsep PBO, akan tetapi Java merupakan bahasa yang mendukung penuh PBO, di antaranya karena Java memiliki beberapa fitur penting yang berbeda dari bahasa standar. Untuk menggunakan fitur ini, kita harus mengubah cara pandang kita terlebih dahulu.

Objek terkait erat dengan kelas. Kita telah bahas dan mencoba beberapa contoh kelas pada bab-bab sebelumnya. Seperti kita lihat pula bahwa kelas memiliki variabel dan subrutin.

Jika objek juga memiliki variabel dan subrutin, lalu apa bedanya dengan kelas? Lalu mengapa kita harus memiliki cara pandang berbeda dengan cara kita melihat kelas? Sepertinya apabila kita lihat contoh-contohnya sebelumnya, perbedaannya hanya menghilangkan kata "static" dari deklarasi variabel dan subrutinnya, khan?

Seperti disebutkan sebelumnya bahwa kelas mendeskripsikan suatu objek, atau lebih tepatnya, bagian non "static" mendeskripsikan suatu objek. Mungkin bahasa biologi, kelas adalah species, sedangkan objek merupakan individu. Human sapiens (nama biologi manusia) adalah kelas, sedangkan Anda, saya, ibu, bapak, pak hansip adalah objek. Masing-masing dari kita memiliki "blueprint" atau cetak biru yang sama, tetapi kita memiliki ciri-ciri yang berbeda, rambut, mata, telinga, tinggi badan, berat badan, dan juga perilaku kita saat makan, minum, belajar, dan lain-lain.

Dalam sudut pandang pemrograman, kelas digunakan untuk menciptakan suatu objek. Atau dengan kata lain, kelas adalah pabrik pembuat objek. Bagian non-statik dari suatu kelas adalah bagian yang memuat detail suatu objek, yaitu apa isi variabel dan metodenya. Perbedaan kelas dan objek adalah : Objek diciptakan dan dihancurkan ketika program berjalan, sehingga kita bisa memiliki beberapa objek sekaligus.

Kita lihat contoh sederhana, dimana kelas sederhana digunakan untuk menggabungkan beberapa variabel statik. Misalnya

class DataPenduduk {
    static String nama;
    static int umur;
}

Dalam hal ini tidak ada lagi yang variabel DataPenduduk.nama dan DataPenduduk.umur, karena nama dan umur bukan anggota statik kelas DataPenduduk. Jadi, tidak ada yang bisa kita lakukan dengan kelas ini sama sekali, kecuali membuat objek dari kelas ini.

Setiap objek akan memiliki variable sendiri yang dinamakan "nama" dan "umur". Kita bisa membuat banyak "penduduk" karena kita bisa membuat objek untuk setiap penduduk. Misalnya setiap kali seseorang dilahirkan, kita bisa membuat objek penduduk baru. Atau jika seseorang meninggal dunia, kita bisa hapus objek tersebut.

Suatu sistem yang terdiri dari kumpulan objek digunakan untuk memodelkan apa yang terjadi di alam nyata. Kita tidak bisa membuat beberapa objek dengan menggunakan variabel statik.

Contoh lainnya adalah pada GUI. Bayangkan kita memiliki beberapa tombol, misalnya tombol OK, Cancel dan Apply. Masing-masing tombol ini memiliki kelas yang sama akan tetapi apa yang dilakukan tombol ini berbeda-beda. Teks yang ditampilkan (OK, Cancel atau Apply) merupakan variabel masing-masing objek.

Suatu objek yang diciptakan dari suatu kelas disebut instansi dari kelas tersebut. Variabel yang dimiliki oleh objek disebut variabel instansi. Sedangkan subrutinnya disebut <="" strong="">. (Dalam PBO subrutin disebut metode)

Misalnya dalam kelas DataPenduduk di atas, kemudian kita buat suatu objek dari kelas ini, maka objek yang diciptakan disebut instansi dari kelas DataPenduduk, "nama" dan "umur" adalah variabel instansi di dalam objek tersebut.

Penting untuk diingat bahwa kelas suatu objek menentukan tipe data dari variabel instansi, akan tetapi isi datanya sendiri tidak disimpan di dalam kelas, akan tetapi di dalam objek yang diciptakan, sehingga setiap objek akan memiliki data masing-masing.

Begitu juga dengan metode instansi, misalnya pada kelas tombol, kita memiliki metode yang dinamakan klik(). Masing-masing tombol akan melakukan tugas berbeda-beda tergantung dari objeknya.

Seperti kita lihat di sini bahwa bagian statik dan non-statik dari suatu kelas merupakan hal yang sama sekali berbeda. Banyak kelas yang hanya memiliki anggota statik, atau hanya memiliki anggota non-statik. Akan tetapi kita juga bisa mencampur keduanya dalam suatu kelas. Variabel anggota statik suatu kelas juga bisa disebut variabel kelas dan metode anggota statik suatu kelas juga bisa disebut metode kelas, karena mereka adalah milik kelas dan bukan milik objek yang diciptakan dari suatu kelas.

Sekarang kita gunakan contoh yang lebih real. Kita akan buat versi sederhana dari kelas Murid, dimana kita akan menyimpan informasi tentang murid yang terdaftar pada suatu sekolah.

class Murid {
    String nama ;    // nama murid
    double nilai1, nilai2, nilai3;    // nilai ulangan murid tersebut
    double hitungRataRata() {    // hitung rata-rata nilai ulangan
        return (nilai1 + nilai2 + nilai3) / 3;
    }
}

Kita lihat bahwa semua anggota kelas tersebut bukan anggota statik, artinya kelas ini hanya bisa digunakan untuk membuat objek. Definisi kelas ini artinya bahwa di dalam objek yang akan diciptakan, akan ada variabel instansi yang bernama nama, nilai1, nilai2, dan nilai3, dan juga metode instansi yang bernama hitungRataRata(). Setiap murid memiliki nilai rata-rata yang berbeda-beda. (Makanya ini disebut perilaku suatu objek berbeda-beda).

Dalam Java, kelas merupakan tipe data, yaitu mirip dengan tipe data bawaan seperti int atau boolean. Jadi nama kelas bisa digunakan untuk menentukan tipe suatu variabel dalam deklarasi pernyataan, dalam parameter formal dan juga dalam tipe keluaran suatu fungsi. Misalnya, program mendefinisikan seorang murid dengan pernyataan seperti :

Murid amir;

Akan tetapi membuat variabel seperti di atas TIDAK menciptakan objek. Initinya, ini adalah hal Yang Sangat Amat Penting :

Dalam Java, tidak ada variabel yang bisa menyimpan objek. Variabel hanya bisa menyimpan referensi (alamat di memori) suatu objek. Komputer akan menggunakan referensi ini untuk mencari objek di dalam memori.

Objek diciptakan dengan pernyataan new, yang bertugas menciptakan objek kemudian mengembalikan referensi ke objek yang sudah diciptakan. Misalnya amir adalah variabel dengan tipe Murid seperti dideklarasikan di atas, maka pernyataan berikut :

amir = new Murid();

akan membuat objek yang merupakan instansi dari kelas Murid. Variabel amir akan menyimpan referensi ke objek yang baru saja diciptakan.
Sekarang anggap variabel amir merujuk pada objek yang diciptakan dari kelas Murid. Dalam objek tersebut terdapat variabel nama, nilai1, nilai2, dan nilai3. Variabel instansi ini bisa dipanggil dengan amir.nama, amir.nilai1, amir.nilai2, dan amir.nilai3. (Ingat aturan penulisan nama lengkap, akan tetapi karena kelas ini tidak memiliki anggota statik, dan hanya objek yang diciptakan dari kelas ini memiliki variabel atau metode ini, maka nama lengkapnya diturunkan dari nama objek yang memilikinya).
Misalnya, program berikut :

System.out.println("Hai, " + amir.nama + " . Nilai Anda adalah : ");
System.out.println(amir.nilai1);
System.out.println(amir.nilai2);
System.out.println(amir.nilai3);

Program di atas akan mencetak nama dan nilai-nilai yang disimpan oleh objek amir. Begitu juga kita bisa menghitung rata-rata pada suatu objek dengan menggunakan amir.hitungRataRata(). Sehingga untuk menghitung rata-rata murid tersebut, bisa kita perintahkan dengan:

System.out.println("Nilai rata-rata Anda adalah : " + amir.hitungRataRata());

Lebih umum lagi, kita bisa menggunakan amir.nama seperti layaknya variabel bertipe String, artinya kita bisa menghitung jumlah karakter dengan menggunakan amir.nama.length().

Kita juga bisa membuat variabel seperti amir untuk tidak menunjuk atau memiliki referensi ke obek mana pun. Dalam hal ini kita sebut bahwa objek amir berisi referensi kosong (null reference). Referensi kosong ini ditulis dalam Java dengan ekspresi "null". Dan kita bisa menyimpan nilai "null" pada variabel amir dengan perintah :

amir = null;

Dan kita juga bisa uji apakah amir berisi referensi kosong dengan perintah

if (amir == null) . . .

Jika suatu variabel berisi referensi kosong, maka tentu saja, kita tidak bisa mengambil variabel instansi dan menjalankan metode instansi, karena tidak ada objek yang dirujuk pada variabel tersebut. Misalnya jika variabel amir berisi null, maka kita tidak bisa mengambil variabel amir.nilai1.

Jika program kita mencoba mengakses referensi kosong secara ilegal, maka di tengah-tengah jalannya program, program akan menampilkan pesan kesalahan "null pointer exception".

Mari kita lihat beberapa pernyataan yang bisa digunakan dengan objek :

Murid mrd1, mrd2, mrd3, mrd4;    // mendeklarasikan 4 variabel yang bertipe Murid
mrd1 = new Murid();              // membuat objek baru dari kelas Murid, kemudian menyimpan referensinya pada variabel mrd1
mrd2 = new Murid();              // membuat objek baru dari kelas Murid, kemudian menyimpan referensinya pada variabel mrd2
mrd3 = mrd1;                     // menkopi „referensi" yang disimpan pada mrd1 ke mrd3
mrd4 = null;                     // menyimpan referensi kosong ke mrd4
 
mrd1.nama = "Ahmad Surahmat";    // mengisi nilai variabel instansi
mrd2.nama = "Hamid Samsudin";

Setelah komputer menjalankan program tersebut, maka kira-kira memori komputer akan tampak seperti gambar berikut :

Gambar tersebut menunjukkan variabel dalam kotak-kotak kecil dengan nama variabelnya. Objek ditunjukkan dalam kotak dengan pojok bulat. Ketika suatu variabel berisi referensi ke suatu objek, maka nilainya adalah seperti panah yang menunjuk pada objek tersebut.

Variabel mrd4 bernilai null, sehingga tidak menunjuk ke mana-mana. Panah dari mrd1 dan mrd3 menjunjuk pada objek ang sama. Ini merupakan Hal Yang Sangat Penting :

Jika isi variabel suatu objek diberikan kepada variabel yang lain, maka yang dikopi hanya referensinya saja. Isi objek tidak pernah dikopi.

Ketika pernyataan "mrd3 = mrd1;" dieksekusi, tidak ada objek baru yang dibuat. Akan tetapi mrd3 akan merujuk pada alamat yang sama seperti mrd1. Konsekuensinya mungkin sedikit mengejutkan. Misalnya variabel mrd1.nama dan mrd3.nama menunjuk pada variabel yang persis sama, maka apabila mrd1.nama disi dengan "Juju Juminten", maka mrd3.nama juga berisi "Juju Juminten".

Sekali lagi, variabel tidak berisi objek, akan tetapi berisi referensi ke suatu objek.

Kita bisa menguji beberapa objek dengan operator == dan != untuk menguji kesamaan dan ketidaksamaan. Akan tetapi yang dicek lagi-lagi bukan isi objek, melainkan alamat memori dimana objek tersebut dijadikan referensi. Jika alamat referensi di memori sama, artinya kedua objek tersebut merujuk pada alamat memori yang sama. Ini berarti perubahan yang dilakukan pada variabel yang satu akan ikut mempengaruhi variabel yang lain.

Untuk menguji isinya, maka isinya harus dibandingkan satu per satu, yaitu misalnya dengan "mrd3.nilai1 == mrd1.nilai1 && mrd3.nilai2 == mrd1.nilai2 && mrd3.nilai3 == mrd1.nilai3 && mrd3.nama.equals(mrd1.nama)"

Seperti telah disebutkan sebelumnya bahwa String juga merupakan objek. Sehingga membandingkan String yang satu dengan String yang lain dengan menggunakan tanda == adalah membandingkan apakah alamat memori yang ditunjuk oleh String yang satu sama dengan alamat memori yang ditunjuk oleh String yang lain. Ingat == pada objek bukan membandingkan isi objek, tetapi membandingkan alamat memori yang ditunjuk oleh variabel tersebut. Untuk membandingkan isi String, kita dapat menggunakan String.equals() di mana parameternya adalah objek String yang akan dibandingkan. Metode ini akan membandingkan karakter per karakter dari kedua String.

Misalnya, variabel salam berisi String "Selamat". Untuk menguji apakah variabel salam berisi "Selamat", bisa kita gunakan perintah,

salam.equals("Selamat")

Konsekuensi lainnya adalah apabila suatu variabel merujuk pada objek yang dideklarasikan sebagai final. Ini berarti nilai variabel itu tidak bisa berubah setelah diinisialisasi, sedangkan isi variabel itu adalah rujukan ke alamat memori tempat objek berada. Dengan demikian variabel tersebut akan selalu menunjuk pada alamat memori yang sama. Akan tetapi hal ini tidak berlaku untuk objek itu sendiri. Apabila ada variabel lain yang tidak "final" tetapi menunjuk pada alamat memori yang sama, kemudian variabel ini mengubah isi objek tersebut, maka isi objek tersebut bisa berubah.

Kita boleh saja untuk menulis perintah sebagai berikut.

final Murid mrd = new Murid();
murid.nama = "Ahmad Basir";

Perhatikan pada kode di atas bahwa isi objek bisa diubah. Akan tetapi jika kita mencoba menulis seperti ini

Murid mrd99 = new Murid();
mrd = mrd99; // ILEGAL, karena mrd adalah variabel final

Read More

Perancangan Algoritma

Pada dasarnya sebuah perangkat komputer adalah mesin yang labih, komputer hanya mengerjakan apa yang kita inginkan melalui instruksi-instruksi yang kita berikan. tanpa instruksi dari kita komputer itu hanya sebuah mesin yang tidak bisa beraktifitas dengan sendirinya.
Programmer adalah orang yang bertugas untuk menerjemahkan suatu tugas menjadi instruksi detail yang dapat dimengerti oleh komputer. Komputer hanya melakukan apa yang diperintahkan baris demi baris, tetapi komputer tidak bisa berfikir bagaimana melakukan suatu tugas seefisien mungkin.
Untuk itu programmer baru harus dilengkapi dengan cara berfikir dan peralatan yang memungkinkan mereka untuk sukses dalam menerjemahkan suatu tugas menjadi rangkaian perintah yang bisa dimengerti oleh komputer.
Program komputer itu seperti seni yang memuat suatu ide. Seorang programmer mulai dengan suatu tugas di kepalanya, misalnya menghitung sisi miring dari segitiga siku-siku. Kemudian dia akan berfikir tentang apa yang harus dilakukan untuk menyelesaikan tugas tersebut dalam bahasa manusia. Dalam hal ini misalnya, sisi miring dapat dihitung dengan mengambil akar kuadrat dari jumlah kuadrat sisi siku-sikunya. Pemecahan masalah ini kemudian diterjemahkan ke dalam bahasa pemrograman yang berupa perintah langkah demi langkah bagaimana komputer harus menyelesaikan tugas tersebut.
Perintah langkah demi langkah hingga detail ini disebut algoritma. (Secara teknis, algoritma adalah kumpulan langkah-langkah sederhana yang jelas, tidak membingungkan karena hanya ada satu cara untuk melakukan langkah sederhana tersebut, dilakukan selama kurun waktu tertentu. Kita tidak ingin program menghitung selamanya tanpa batas waktu.)
Program ditulis dalam bahasa pemgrograman tertentu. Tetapi algoritma ditulis secara umum atau generic, dalam bahasa manusia, sehingga bisa diimplementasikan menggunakan bahasa pemrograman apapun. Atau dengan kata lain, algoritma mirip seperti ide di belakang program yang akan kita tulis. Tetapi ide tersebut harus jelas, dan memuat langkah demi langkah yang sederhana.
Jadi darimana algoritma itu datang? Biasanya orang harus membuat algoritma itu. Dengan skill, latihan dan pengalaman, orang akan lebih mudah membuat suatu algoritma.
Di bagian ini akan dibahas tentang bagaimana membuat suatu algoritma. Jadi bahasa Java akan kita tinggalkan sementara. Kita akan beralih untuk berfikir secara abstrak.
Misalnya, kita memiliki suatu tugas di kepala. Salah satu cara untuk menyelesaikan tugas itu adalah menuliskan penyelesaiannya langkah demi langkah, dan dari sana kita membuat algoritma untuk menyelesaikan masalah itu. Kemudian dari setiap langkah tersebut, kita bisa membuat langkah-langkah lain yang lebih detail, sampai kita bisa menerjemahkan langkah-langkah itu ke dalam bahasa pemrograman. Metode ini disebut penghalusan bertahap (stepwise refinement), dan sifatnya top-down atau dari atas ke bawah. Sambil kita menambah detail pada setiap langkah, kita bisa mulai menuliskan algoritma dalam bentuk pseudocode (kode palsu) yang bentuknya tidak harus persis atau mengikuti suatu bahasa pemrograman. Misalnya, kita ambil contoh untuk menghitung rata-rata dari 5 bilangan. Kita bisa menuliskan pseudocode dalam bentuk berikut :

ambil input user untuk bilangan pertama
masukkan ke variabel x
ambil input user untuk bilangan kedua
tambahkan variabel x dengan bilangan kedua
ambil input user untuk bilangan ketiga
tambahkan variabel x dengan bilangan ketiga
ambil input user untuk bilangan keempat
tambahkan variabel x dengan bilangan keempat
ambil input user untuk bilangan kelima
tambahkan variabel x dengan bilangan kelima
bagi variabel x dengan 5
tampilkan hasilnya di layar

Algoritma di atas betul, tetapi terlalu banyak perulangan. Bagaimana jika bilangan yang akan dirata-ratakan ada 100? Kita bisa udah algoritma di atas dengan pseudocode yang lebih mudah dimengerti. misalnya,

while a kurang dari 5
    ambil input user untuk bilangan ke-a
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Sekarang, ambil input user bisa dideskripsikan lebih jauh. Kita harus memberikan pertanyaan kepada user. Dan seperti dipelajari pada bab sebelumnya, input dari user berupa String yang harus diterjemahkan ke dalam tipe data bilangan untuk bisa dikalkulasi. Pseudocode di atas dapat ditulis ulang sebagai berikut :

while a kurang dari 5
    beri pertanyaan kepada user untuk memasukkan bilangan ke-a
    ambil input user untuk bilangan ke-a
    ubah input menjadi bilangan
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Dan juga dari pelajaran sebelumnya, untuk mengambil input user, kita bisa dihadapkan pada permasalahan IO (input output). Selain itu kita juga harus menginisialisasi pembaca dan tempat meletakkan string sementara. Untuk itu, kita harus mengubah pseudocode nya menjadi seperti ini,

inisialisasi pembaca
inisialisasi tempat string sementara
while a kurang dari 5
    beri pertanyaan kepada user untuk memasukkan bilangan ke-a
    "coba" ambil input user untuk bilangan ke-a
        jika ada masalah keluar dari program
    ubah input menjadi bilangan
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Kemudian, perlu diperhatikan bahwa variabel a dan x tidak diketahui nilai awalnya oleh komputer. Bayangkan jika nilai a dan x ditentukan oleh komputer secara acak, bukan saja hasil rata-ratanya menjadi tak tentu, tetapi juga perulangannya menjadi tak menentu. Untuk itu kita harus tambahkan perintah untuk menginisialisasi a dan x dengan 0, sehingga pseudocodenya menjadi,

inisialisasi x dengan 0
inisialisasi a dengan 0
inisialisasi pembaca
inisialisasi tempat string sementara
while a kurang dari 5
    beri pertanyaan kepada user untuk memasukkan bilangan ke-a
    "coba" ambil input user untuk bilangan ke-a
        jika ada masalah keluar dari program
    ubah input menjadi bilangan
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Dari sini kita bisa menerjemahkan pseudocode tersebut menjadi program Java, yaitu,

double x = 0;
int a = 0;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String strbilangan = null;
 
while (a < 5) {
    System.out.print("Masukkan bilangan ke-" + a + " : ");
    try {
        strbilangan = br.readLine();
    } catch (IOException ioe) {
        System.out.println("Kesalahan IO, program berhenti");
        System.exit(1);
    }
    x = x + Double.parseDouble(strbilangan);
    a = a + 1;
}
x = x / 5;
System.out.println("Rata-rata bilangan yang dimasukkan adalah " + x);

Jangan lupa bahwa program tersebut membutuhkan paket java.io.*, sehingga kita harus menambah,

import java.io.*

di awal kelas.

Berikut ini adalah program lengkapnya dan dapat diunduh dalam bentuk zip file atau melalui SVN di alamat berikut disini

package hitungratarata5bil;
 
import java.io.*;
 
public class HitungRataRata5Bil {
 
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  double x = 0;
  int a = 0;
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  String strbilangan = null;
 
  while (a < 5) {
      System.out.print("Masukkan bilangan ke-" + a + " : ");
      try {
          strbilangan = br.readLine();
      } catch (IOException ioe) {
          System.out.println("Kesalahan IO, program berhenti");
          System.exit(1);
      }
      x = x + Double.parseDouble(strbilangan);
      a = a + 1;
  }
 
  x = x / 5;
  System.out.println("Rata-rata bilangan yang dimasukkan adalah " + x); 
 }
}

Untuk menguji program tersebut, jalankan "Run -> Run" atau Ctrl-F11. Kemudian arahkan kursor Anda ke bagian bawah dan klik di kotak yang bernama Console.

 Berikut ini adalah hasil keluarannya, Anda bisa mencoba-coba dengan bilangan apapun.

Read More

Blok, Perulangan, dan Percabangan

Kemampuan suatu program untuk melakukan tugas kompleks dilakukan dengan menggabungkan perintah sederhana menjadi struktur kontrol. Dalam bahasa Java, ada 6 struktur tersebut, yaitu blok, perulangan while, perulangan do ... while, perulangan for, pernyataan if, dan pernyataan switch.

Masing-masing struktur ini sebetulnya merupakan pernyataan tunggal yang berdiri dengan sendirinya, tetapi di dalamnya terdiri dari satu atau lebih perintah sehingga keseluruhannya menjadi suatu struktur perintah.

Blok
Blok adalah pernyataan sederhana yang dimulai dengan { dan diakhiri dengan }. Tujuannya untuk mengelompokkan beberapa perintah sehingga lebih dimengerti. Misalnya,

{
     perintah
}

Pernyataan blok biasanya terdapat dalam struktur kontrol, tetapi sebetulnya tanpa struktur kontrol pun, blok tetap berlaku. Contoh sederhana penggunaan blok ini adalah dalam subrutin main() yang kita lakukan pada contoh-contoh sebelumnya.

Berikut ini adalah 2 contoh penggunaan blok.

{
    System.out.println("Hallo");
    System.out.println("Dunia");
}
 
{ // blok ini digunakan untuk menukar isi variable x dan y
    int temp;
    temp = x;
    x = y;
    y = temp;
}

Pada blok kedua, kita mendeklarasikan variable baru temp. Dalam blok kedua ini, variabel apapun yang dideklarasikan tidak akan dapat diakses dari luar blok ini. Variabel ini disebut variabel lokal, karena hanya bisa diakses dari dalam blok.
Ketika komputer menjalankan program ini, komputer akan mempersiapkan memori untuk menyimpan variabel yang dideklarasikan di dalam blok ini. Ketika blok ini selesai dijalankan, komputer akan melepas memori yang digunakan dalam blok ini untuk digunakan oleh bagian program lain.
Konsep "scope" atau jangkauan pada konsep pemrograman, mengacu pada bisa atau tidaknya suatu variabel dilihat oleh bagian program lain. Jangkauan suatu variabel menyatakan di bagian mana variabel ini valid atau dengan kata lain bisa diakses. Jangkauan variabel dalam suatu blok terbatas hanya pada blok tersebut.
Blok sendiri sebetulnya bukan merupakan struktur kontrol. Program akan berjalan seperti biasa dari atas kebawah seperti biasa. Secara umum struktur kontrol dibagi menjadi 2 bagian, yaitu : perulangan dan percabangan.
 
Perulangan 
Sebagai contoh untuk membahas tentang perulangan, kita lihat pernyataan while, yang memiliki bentuk seperti,

while (suatu_kondisi) {
   perintah
}

Semantik pada pernyataan while tersebut adalah sebagai berikut. Ketika komputer sampai pada pernyataan while, komputer akan melakukan perhitungan pada suatu_kondisi. Apabila suatu_kondisi bernilai true, blok yang berisi perintah akan dilakukan. Setelah komputer sampai pada bagian akhir blok, komputer akan menghitung kembali suatu_kondisi. Jika masih bernilai true, maka blok tersebut akan dieksekusi, dan jika tidak, program akan melompat ke bagian program berikutnya setelah blok berakhir. Atau dengan kata lain, jika suatu_kondisi bernilai false, blok perintah tidak akan dieksekusi.
Berikut ini adalah contoh untuk menulis bilangan 1 hingga 5.

int angka = 1; // inisialisasi variabel, kita mulai dengan mengisi variabel angka dengan 1
 
while (angka <= 5) {
     System.out.println(angka); // cetak isi angka di layar
     angka = angka + 1;         // tambah angka dengan 1
}
 
System.out.println("Selesai...");

Variabel angka kita inisialiasi (persiapkan) dan kita isi mula-mula dengan 1. Ketika program sampai pada pernyataan while, program akan mengevaluasi apakah angka <= 5. Pada saat program baru dimulai, angka masih bernilai 1, sehingga pernyataan angka <= 5 bernilai true. Dalam hal ini perintah di dalam blok akan dieksekusi, yaitu mencetak angka ke layar, kemudian menambah angka dengan 1. Sekarang angka bernilai 2.
Setelah sampai pada akhir blok, program akan kembali pada awal pernyataan while. Sekarang angka bernilai 2, dan karena 2 masih kurang dari atau sama dengan 5, program akan kembali mengeksekusi perintah dalam blok. Begitu seterusnya hingga angka bernilai 6. Pada saat ini program akan berhenti melakukan perulangan dan berhenti melakukan eksekusi perintah di dalam blok tersebut, kemudian melakukan perintah berikutnya, yaitu menampilkan kata "Selesai...".

Percabangan
Pernyataan if memperintahkan komputer untuk memilih salah satu aksi yang akan dilakukan, tergantung pada suatu kondisi tertentu. Bentuknya dapat ditulis sebagai berikut,

if (suatu_kondisi)
     perintah_1;
else
     perintah_2;

Perintah_1 dan perintah_2 juga bisa berbentuk blok, sehingga pernyataan di atas dapat ditulis juga sebagai berikut,

if (suatu_kondisi) {
     perintah_1;
} else {
     perintah_2;
}

Ketika komputer sampai pada pernyataan if, komputer akan menghitung apakah suatu_kondisi bernilai true. Jika iya, maka blok perintah berikutnya akan dieksekusi, dalam hal ini perintah_1. Jika tidak, maka blok setelah pernyataan else akan dieksekusi, yaitu perintah_2.
Sebagai contoh, mari kita kembali pada contoh program untuk membalik nilai x dan y, dengan syarat x harus lebih besar dari y. Dalam hal ini, setelah program ini dieksekusi, nilai x akan selalu bernilai lebih kecil dari y, karena jika nilai x lebih besar, nilai x akan ditukar dengan nilai y.

if (x > y) { // jika x lebih besar dari y
    // blok ini digunakan untuk menukar isi variable x dan y
    int temp;
    temp = x;
    x = y;
    y = temp;
}

Contoh berikut adalah program untuk menentukan apakah suatu bilangan merupakan bilangan genap atau bilangan ganjil. Dengan menggunakan operator %, yaitu sisa pembagian, kita dapat menentukan apabila sisa pembagian suatu bilangan dengan 2 adalah 0, maka bilangan tersebut merupakan bilangan genap. Jika tidak, maka bilangan tersebut adalah bilangan ganjil.

if ((x % 2) == 0) {
    System.out.println(x + " adalah bilangan genap");
} else {
    System.out.println(x + " adalah bilangan ganjil");
}

Read More

INSTALASI NETBEANS

Sejarah Netbeans
Pengembangan  NetBeans  diawali  dari  Xelfi,  sebuah  proyek  mahasiswa  tahun  1997  di  bawah bimbingan Fakultas Matematika dan Fisika Universitas  Charles,  Praha.
Sebuah  perusahaan  kemudian  dibentuk  untuk  proyek  tersebut  dan  menghasilkan  versi  komersial  NetBeans  IDE  hingga  kemudian  dibeli  oleh  Sun  Microsystem  pada  tahun  1999.  Sun  kemudian  menjadikan  NetBeans  open  source  pada  bulan  Juni  tahun  2000. Sejak itu komunitas NetBeans terus berkembang.
NetBeans  mengacu  pada  dua  hal,  yakni  platform  untuk  pengembangan  aplikasi desktop  java,  dan  sebuah  Integrated Development  Environment  (IDE) yang  dibangun menggunakan platform NetBeans.
 Platform NetBeans memungkinkan aplikasi dibangun dari sekumpulan komponen  perangkat  lunak  moduler  yang  disebut  ‘modul’.  Sebuah  modul  adalah  suatu arsip  Java  (Java archive)  yang memuat kelas-kelas Java untuk berinetraksi dengan  NetBeans Open API  dan  file  manifestasi  yang  mengidentifikasinya sebagai  modul.  Aplikasi  yang dibangun  dengan  modul-modul  dapat  dikembangkan  dengan  menambahkan  modul-modul  baru.  Karena  modul  dapat dikembangkan  secara  independen,  aplikasi  berbasis platform NetBeans  dapat dengan mudah dikembangkan oleh pihak ketiga  secara mudah dan powerful.

Platform NetBeans
Platform  NetBeans  adalah  framework  yang  dapat  digunakan  kembali  (reusable) untuk  menyederhanakan  pengembangan  aplikasi  desktop.  Ketika  aplikasi berbasis platform NetBeans dijalankan, kelas Main dari platform dieksekusi. Modul-modul yang tersedia  ditempatkan  di  sebuah  registry  di  dalam  memori, dan  tugas  startup  modul dijalankan.  Secara  umum,  kode  modul  dimuatkan  ke  dalam  memori  hanya  ketika  ia diperlukan.
Aplikasi  dapat  menginstal  modul  secara  dinamis.  Aplikasi  dapat  memasukkan modul  Update  Center  untuk  mengijinkan  pengguna  aplikasi  men-download digitally-signed  upgrade  dan  fitur-fitur  baru  secara  langsung  ke  dalam  aplikasi  yang  berjalan. Penginstalan  kembali  sebuah  upgrade  atau  rilis baru  tidak  memaksa  pengguna  untuk men-download keseluruhan aplikasi lagi.
Platform  NetBeans  menawarkan  layanan-layanan  yang  umum  bagi  aplikasi desktop, mengijinkan pengembang untuk fokus ke logika yang spesifik terhadap aplikasi.
Fitur-fitur yang disediakan oleh platform NetBeans:

• Manajemen antarmuka (misal: menu & toolbar)
• Manajemen pengaturan pengguna
• Manajemen penyimpanan (menyimpan dan membuka berbagai macam data)
• Manajemen jendela
• Wizard framework (mendukung dialog langkah demi langkah)

Sebelum menginstal Netbeans IDE 6.5.1 teman-teman harus menginstal paket Java Development Kit (JDK) terlebih dahulu. Netbeans IDE berguna untuk membangun aplikasi java (salah satunya).
Untuk File JDK dan Netbeans.exe bisa didownload di sini
Cara instalnya adalah sebagai berikut;

1. Klik 2x Installer Netbeans IDE, sehingga muncul form Configuring Installer.

2. Tunggu sampai proses konfigurasi ini selesai.

3. Pilih paket program yang akan diinstall dengan cara klik tombol Customize... (sudah diset otomatis semua paket diinstall). Klik Next.

4. Beri tanda centang pada I accept the terms in the license agreement. Klik Next.

5. Tentukan lokasi instalasi GlashFish (sudah diset otomatis), GlashFish berguna bagi teman-teman sewaktu menjalankan aplikasi  desktop yang teman-teman buat nantinya menggunakan web browser. Teman-teman harus perhatikan dan ingat username, password, port dan lokasi instalasi, jika perlu teman-teman catat. saja Klik Next.

6. Tentukan Lokasi GlashFlash v3 (sudah diset otomatis). Klik Next.

7. Pada form summary akan ditampilkan informasi mengenai instalasi Netbeans IDE yang akan dilakukan. Klik Install.

8. Tunggu sampai proses instalasi selesai.

9. Instalasi telah sukses dilakukan. Klik Finish.

 

Selamat mencoba.

Read More