Interface, Class Bertingkat, dan Detail Lain

Interface (Antar Muka)

Beberapa bahasa pemrograman berorientasi objek, misalnya C++, membolehkan suatu kelas memiliki dua atau lebih kelas super. Hal ini disebut pewarisan ganda (multiple inheritance). Pada ilustrasi berikut, kelas E memiliki kelas super A dan B, sedangkan kelas F memiliki 3 kelas super.

Pewarisan ganda seperti ini tidak diperbolehkan pada Java. Desainer Java ingin menjaga agar bahasa Java tetap sederhana, dan mereka merasa pewarisan ganda ini sangat kompleks dengan keuntungan yang tidak begitu besar. Akan tetapi, Java memiliki fitur lain yang bisa digunakan seperti halnya pewarisan berganda, yaitu antar muka (interface).

Kita telah mengenal istilah "antar muka" sebelumnya, yaitu dalam konteks umum tentang kotak hitam dan subrutin. Antar muka suatu subrutin terdiri dari nama, jenis keluarannya, jumlah dan tipe parameternya. Informasi ini dibutuhkan jika kita ingin memanggi subrutin tersebut. Suatu subrutin juga memiliki implementasi : yaitu blok yang berisi perintah yang akan dijalankan ketika subrutin ini dipanggil.

Dalam Java, kata interface adalah kata kunci yang memiliki arti tambahan. Suatu interface dalam hal ini adalah antar muka yang terdiri dari subrutin tanpa implementasi apa-apa. Suatu kelas dapat mengimplementasi suatu interface dengan memberikan kode detail pada setiap subrutin yang ditulis pada interface tersebut. Berikut adalah contoh interface Java sederhana :

public interface Gambar {
    public void gambar(Graphics g);
}

Deklarasi di atas mirip dengan definisi suatu kelas, akan tetapi isi metode gambar() dikosongkan. Suatu kelas yang mengimplementasi interface ini, yaitu interfaceGambar, harus mengisi implementasi metode gambar() ini. Tentunya kelas tersebut juga bisa memiliki variabel dan metode lain. Misalnya,

class Garis implements Gambar {
    public void gambar(Graphics g) {
        . . . // perintah untuk menggambar garis
    }
    . . . // variabel dan metode lain
}

Kelas apapun yang mengimplementasi antar muka Gambar[code] harus memberikan detail apa yang akan dilakukan oleh metode [code]gambar(). Objek yang diciptakan dari kelas tersebut akan memiliki metode gambar(). Perlu diingat bahwa hanya menambah metode gambar() saja tidak cukup. Definisi kelas yang ingin mengimplementasikan suatu interface harus menulis "implements Gambar" dalam definisi kelasnya.

Suatu kelas bisa menurunkan hanya satu kelas lain, akan tetapi suatu kelas bisa mengimplementasikan lebih dari suatu antar muka. Sebenarnya, suatu kelas bisa menurunkan kelas lain dan mengimplementasikan satu atau lebih antar muka sekaligus. Misalnya

class LingkaranBerwarna extends Lingkaran
    implements Gambar, BerisiWarna {
        . . .
    }

Intinya adalah meskipun interface bukan kelas, akan tetapi interface mirip dengan kelas. suatu interface mirip seperti kelas abstrak, yaitu kelas yang hanya digunakan untuk membuat kelas lain, bukan untuk membuat objek. Subrutin pada suatu interface merupakan metode abstrak yang harus diimplementasikan pada kelas kongkrit yang mengimplementasikan interface tersebut.

Seperti kelas abstrak, meskipun kita tidak bisa membuat objek dari interface, akan tetapi suatu variabel dapat bertipe suatu interface. Misalnya, jika Gambar adalah suatu interface, dan jika Garis dan LingkaranBerwarna adalah kelas yang mengimplementasikan Gambar, maka kita bisa menulis kode seperti,

Gambar gambarku; // Deklarasi variabel dengan tipe Gambar.
// Variabel ini bisa diisi objek yang
// mengimplementasi interface Gambar

gambarku = new Garis(); // gambarku berisi objek dengan kelas Garis
gambarku.gambar(g); // memanggil metode gambar() dari kelas Garis

gambarku = new LingkaranBerwarna(); // Sekarang gambarku berisi objek dengan
// kelas LingkaranBerwarna
gambarku.gambar(g); // memanggil metode gambar() dari kelas LingkaranBerwarna

Variabel dengan tipe Gambar boleh merujuk pada kelas apapun yang mengimplementasikan antar muka Gambar. Pernyataan di atas seperti "gambarku.gambar(g)" boleh ditulis karena gambarku adalah variabel dengan tipe Gambar, dan setiap objek bertipe Gambar pasti memiliki metode gambar().

Catatan bahwa tipe data merupakan sesuatu yang biasa digunakan untuk mendeklarasikan variabel. Tipe data juga digunakan untuk memberikan tipe suatu parameter pada subrutin, atau sebagai tipe keluaran suatu fungsi. Pada Java, tipe data bisa berupa kelas, interface, atau salah satu dari 8 tipe data primitif. Dari semuanya, hanya kelas yang bisa digunakan untuk membuat objek baru.

Kita biasanya tidak perlu menulis interface kita sendiri hingga program kita menjadi sangat kompleks. Akan tetapi ada beberapa interface yang sudah disediakan oleh Java yang mungkin bisa digunakan atau diimplementasi dalam program kita.

Class Bertingkat

Suatu kelas merupakan blok bangunan suatu program, yang melambangkan suatu ide beserta data dan perilaku yang dimilikinya. Kadang-kadang kita mungkin berasa sedikit aneh untuk membuat kelas kecil hanya untuk menggabungkan beberapa data. Akan tetapi kadang-kadang kelas-kelas kecil ini sering bermanfaat dan penting. Untungnya Java membolehkan kita untuk membuat kelas di dalam kelas lain, sehingga kelas-kelas kecil ini tidak perlu berdiri sendiri. Kelas kecil ini menjadi bagian dari suatu kelas besar yang bisa melakukan hal-hal kompleks lainnya. Kelas kecil ini misalnya berguna untuk mendukung operasi yang akan dikerjakan oleh kelas besarnya.

Dalam Java, kelas bertingkat atau kelas bagian dalam adalah kelas yang ditulis di dalam definisi kelas lain. Kelas bagian dalam ini bisa memiliki nama atau anonim (tanpa nama). Kelas bagian dalam yang memiliki nama tampak seperti kelas biasa, tetapi ia ditulis di dalam kelas lain. (Kelas bagian dalam ini juga bisa memiliki kelas bagian dalam yang lain, akan tetapi ingat akan konsekuensi kerumitannya apabila kita membuat terlalu banyak tingkatan).

Seperti komponen lain dalam suatu kelas, kelas bagian dalam yang memiliki nama bisa berupa kelas statik atau kelas non-statik. Kelas bertingkat statik merupakan bagian dari struktur statik dari kelas yang menaunginya. Kelas tersebut bisa digunakan di dalam kelas induknya untuk membuat objek seperti biasa. Jika tidak dideklarasikan sebagai private, makan kelas tersebut juga bisa digunakan dari luar kelas induknya. Jika digunakan dari luar kelas induknya, namanya harus jelas mencantumkan nama kelas induknya. Mirip seperti komponen statik dari suatu kelas : kelas bertingkat statik adalah bagian kelas di mana kelas tersebut mirip dengan variabel anggota statik lainnya di dalam kelas tersebut.

Misalnya, suatu kelas bernama ModelRangkaKawat melambangkan kumpulan garis dalam ruang 3 dimensi. Misalnya kelas ModelRangkaKawat memiliki kelas bertingkat statik yang bernama Garis yaitu sebuah garis. Maka dari luar kelas ModelRangkaKawat, kelas Garis akan dipanggil sebagai ModelRangkaKawat.Garis.

Kelas ModelRangkaKawat dan kelas bagian dalamnya dapat dituliskan seperti berikut :

public class ModelRangkaKawat {
 
    . . . // anggota lain kelas ModelRangkaKawat
 
    static public class Garis {
        // Melambangkan garis dari titik (x1,y1,z1)
        // ke titik (x2,y2,z2) dalam ruang 3-dimensi
        double x1, y1, z1;
        double x2, y2, z2;
    } // akhir kelas Garis
 
    . . . // anggota lain kelas ModelRangkaKawat
 
} // akhir kelas ModelRangkaKawat

Di dalam kelas ModelRangkaKawat, objek Garis bisa dibuat dengan konstruktor "new Garis()". Di luar kelas, perintah "new ModelRangkaKawat.Garis()" harus digunakan.

Kelas bertingkat statik memiliki akses penuh kepada anggota dari kelas induknya, termasuk ke anggota private. Mungkin ini juga motivasi sebagian orang untuk membuat kelas bertingkat, karena kelas bagian dalamnya bisa mengakses anggota private kelas lain tanpa harus membuat variabel atau metode anggotanya menjadi public.

Ketika kita mengkompilasi definisi kelas di atas, dua file kelas akan dibuat. Meskipun definisi kelas Garis berada di dalam ModelRangkaKawat, akan tetapi kelas Garis akan disimpan dalam file terpisah. Nama file kelas Garis akan menjadi ModelRangkaKawat$Garis.class

Kelas bertingkat yang tidak statik, pada prakteknya, tidak jauh berbeda dengan kelas bertingkat statik, akan tetapi kelas bertingkat non-statik berkaitan dengan suatu objek, bukan kelas induknya.

Anggota non-statik dari suatu kelas sebenarnya bukan merupakan bagian dari kelas itu. Hal ini juga berlaku untuk kelas bertingkat non-statik seperti juga bagian kelas non-statik lainnya. Anggota non-statik suatu kelas menjelaskan apa yang akan disimpan dalam objek yang diciptakan dari kelas tersebut. Hal ini juga berlaku (secara logis) dari kelas bertingkat non-statik.

Dengan kata lain, setiap objek yang diciptakan dari kelas induknya memiliki kopi kelas bertingkat masing-masing. Kopi ini memiliki akses ke semua variabel dan metode instansi objek tersebut. Dua objek kelas bagian dalam pada dua objek induk merupakan objek berbeda karena metode dan variabel instansi yang bisa diakses berasal dari objek yang berbeda.

Pada dasarnya, aturan untuk menentukan kapan suatu kelas bisa dimasukkan ke dalam kelas lain sebagai kelas statik atau non-statik adalah : Jika kelas tersebut perlu menggunakan variabel atau metode instansi suatu objek (bukan variabel atau metode statik kelas), maka kelas tersebut harus dibuat non-statik, jika tidak maka harus dibuat statik.

Dari luar kelas induknya, kelas bertingkat non-statik harus dipanggil dalam bentuk namaVariabel.NamaKelasBertingkat, misalnya namaVariabel adalah variabel yang merujuk pada objek yang memiliki kelas bertingkat tersebut. Sebetulnya cara ini agak langka. Kelas bertingkat non-statik biasanya digunakan hanya di dalam kelas induknya, sehingga bisa diakses dengan nama yang sederhana.

UNtuk membuat objek yang merupakan kelas bertingkat non-statik, kita harus membuat objek yang merupakan kelas induknya. (Ketika bekerja di dalam kelas, objek "this" akan secara otomatis digunakan). Objek dari kelas bertingkat tersebut dihubungkan secara permanen dengan objek dari kelas induknya, dan memiliki akses penuh atas anggota kelas induknya.

Mari lihat contoh berikut, dan mungkin bisa memberi pemahaman lebih baik bagaimana kelas bertingkat non-statik sebetulnya merupakan hal yang sangat alami. Misalnya suatu kelas yang melambangkan permainan kartu. Kelas ini memiliki kelas beringkat yang melambangkan para pemainnya. Struktur MainKartu bisa berbentuk seperti :




class MainKartu {  // Melambangkan permainan kartu
    class Pemain {  // Melambangkan salah satu pemain game ini
        .
        .
        .
    } // akhir kelas Pemain
    private Tumpukan tumpukan;      // Tumpukan kartu
 
    .
    .
    .
 
} // akhir kelas MainKartu

Jika game adalah variabel dengan tipe MainKartu, maka game memiliki kelas Pemain[code] sendiri. Dalam metode instansi objek [code]MainKartu, objek Pemain bisa dibuat dengan perintah "new Pemain()", seperti halnya kelas biasa. (Objek Pemain bisa dibuat di luar kelas MainKartu dengan perintah seperti "new game.Pemain()", tapi ini jarang dilakukan). Objek Pemain memiliki akses ke variabel instansi tumpukan dalam objek MainKartu.

Masing-masing objek MainKartu memiliki tumpukan dan Pemain sendiri-sendiri. Pemain kartu pada game tersebut akan menggunakan tumpukan kartunya sendiri sedangkan pemain kartu pada game yang lain akan menggunakan tumpukan kartu lain lagi.

Jika Pemain merupakan kelas bertingkat statik, maka pemain tersebut akan bermain di semua permainan kartu, yang tentu saja tidak mungkin terjadi.

Dalam beberapa kasus, mungkin kita harus menulis kelas bertingkat dan kemudian menggunakan kelas tersebut hanya 1 kali dalam program kita. Apakah berguna membuat kelas bertingkat jika begini kondisinya? Mungkin ya mungkin tidak. Dalam kasus seperti ini kita juga bisa membuat kelas bertingkat anonim. Kelas anonim dapat dibuat dengan menggunakan variasi dari operator new dengan bentuk

new  kelassuper_atau_interface () {
    metode_dan_variabel
}

Konstruktor ini membuat suatu kelas baru tanpa memberi nama, dan pada saat yang sama membuat objek dari kelas tersebut. Bentuk operator [code] seperti ini bisa digunakan dalam pernyataan apapun di mana pernyataan new biasa digunakan. Maksud dari pernyataan di atas adalah untuk membuat : "objek baru di dalam suatu kelas yang namanya sama dengan kelassuper_atau_interface dengan ditambah dengan metode_dan_varaibel baru."

Artinya pernyataan di atas sama dengan membuat objek baru dengan konfigurasi yang baru pula. Kita juga bisa membuat kelas anonim yang diturunkan dari interface. Dalam hal ini, kelas anonim tersebut harus mengimplementasikan semua metode yang dideklarasikan oleh interface tersebut.

Kelas anonim sering digunakan untuk menangani event pada GUI (graphical user interfaces). Misalnya interface Gambar seperti didefinisikan di awal bagian ini. Misalnya kita ingin membuat objek berupa gambar bujur sangkar berisi warna merah dengan ukuran 100 x 100 piksel. Daripada membuat kelas baru kemudian menggunakan kelas tersebut untuk membuat objek, kita bisa menggunakan kelas anonim untuk membuat objek sekaligus dalam satu pernyataan :

Gambar kotakMerah = new Gambar() {
        void gambar(Graphics g) {
            g.setColor(Color.red);
            g.fillRect(10,10,100,100);
        }
};

Tanda titik koma (;) di akhir pernyataan ini bukan bagian dari definisi suatu kelas, tapi merupakan bagian dari pernyataan secara keseluruhan.

Ketika kelas Java dikompilasi, setiap kelas bertingkat anonim akan dibuat dalam file kelas terpisah. Jika nama kelas utama adalah KelasUtama, misalnya, maka nama file kelas untuk setiap kelas bertingkat anonimnya menjadi KelasUtama$1.class, KelasUtama$2.class, KelasUtama$3.class dan seterusnya.

Sifat Akses dalam Class

Suatu kelas dapat dideklarasikan sebagai public, yang bisa diakses dari manapun. Beberapa kelas harus dideklarasikan sebagai publik, misalnya sebagai aplikasi desktop biasa, sehingga sistem operasi bisa menjalankan prosedur main() nya. Kelas pada applet misalnya harus juga dideklarasikan sebagai public supaya bisa diakses oleh web browser.

Jika suatu kelas tidak dideklarasikan sebagai public maka ia hanya akan bisa diakses dari paket yang sama. Bagian ini membahas tentang paket. Kelas yang tidak ditulis dalam suatu paket tertentu akan dimasukkan dalam paket default.

Suatu paket seharusnya terdiri dari beberapa kelas yang saling berhubungan. Beberapa dari kelas ini memang sengaja dibuat public agar bisa diakses dari desktop atau program lain misalnya. Bagian lain, yang merupakan bagian internal dari bagaimana paket tersebut bekerja dan tidak boleh disentuh dari luar, tidak boleh dibuat menjadi public. Paket adalah salah satu jenis dari kotak hitam, dan kelas public dalam paket tersebut adalah antar muka dengan dunia luarnya.

Variabel atau metode anggota suatu kelas juga bisa dideklarasikan sebagai public yang juga berarti bisa diakses dari manapun. Variabel atau metode anggota ini juga bisa dideklarasikan sebagai private yang artinya hanya bisa diakses dari dalam kelas di mana dia dideklarasikan. Membuat variabel menjadi private memastikan bahwa tidak ada bagian lain yang akan bisa mengubah variabel ini kecuali dari dalam kelas atau objek itu sendiri.

Jika kita tidak memberikan sifat akses pada metode atau variabel anggota tertentu, maka ia akan otomatis bisa diakses oleh semua kelas dalam paket yang sama.

Ada satu jenis sifat akses lain yang bisa digunakan pada variabel atau metode anggota kelas, yaitu protected. Sifat protected digunakan apabila kita ingin variabel atau metode anggota tersebut bisa diakses oleh turunan kelas tersebut. Artinya lebih leluasa dari private tapi lebih ketat daripada public. Kelas yang didesain untuk diturunkan, biasanya memiliki anggota protected. Anggota protected digunakan untuk menambah fondasi bagi kelas turunannya, akan tetapi tetap tak terlihat dari dunia luar.

Menggabungkan Statik dan Non-Statik

Seperti disebutkan sebelumnya, kelas dapat memiliki dua kegunaan yang sangat berbeda. Kelas bisa digunakan untuk menggabungkan variabel dan subrutin statik. Atau juga bisa digunakan sebagai produsen pembuat objek. Variabel dan subrutin non-statik dalam suatu kelas akan menentukan metode dan variabel instansi pada objek yang diciptakan dari kelas tersebut. Dalam banyak kasus, suatu kelas dapat melakukan salah satu atau kedua fungsi tersebut secara bersamaan.

Dalam hal anggota statik dan non-statik digabung dalam satu kelas, kelas tersebut mengharapkan adanya interaksi antara bagian statik dan bagian non-statik dari suatu kelas. Misalnya, metode instansinya menggunakan variabel statik atau memanggil subrutin statik. Metode instansi dimiliki oleh suatu objek, bukan oleh kelas tersebut. Karena kita bisa membuat banyak objek dari suatu kelas, di mana setiap objek yang diciptakan memiliki metode instansi masing-masing. Akan tetapi akan hanya ada satu variabel statik yaitu yang dimiliki oleh suatu kelas. Dengan demikian, kita memiliki banyak objek yang bisa mengakses variabel statik tersebut bersama-sama.

Misalnya anggap kita akan menulis kelas PasanganDadu yang menggunakan kelas Random seperti pada bagian sebelumnya untuk mengocok dadu. Objek PasanganDadu perlu mengakses objek Random. Akan tetapi membuat objek Random untuk setiap objek PasanganDadu adalah terlalu berlebihan, karena fungsinya hanya digunakan untuk menghasilkan nilai acak saja. Solusi yang bagus adalah dengan menggunakan variabel static yang digunakan oleh semua objek yang dibuat dari kelas PasanganDadu. Misalnya pada kode berikut ini :

class PasanganDadu {
    private static Random randGen = new Random();
    // (Catatan:  java.util.Random telah diimpor sebelum kelas ini dibuat)
 
    public int dadu1;   // Angka pada dadu pertama
    public int dadu2;   // Angka pada dadu kedua
 
    public PasanganDadu() {
        // Konstruktor. Membuat pasangan dadu dengan angka
        // awal berupa bilangan acak
        kocok();
    }
 
    public void kocok() {
        // Kocok dadu dengan membuat masing-masing dadu
        // bernilai bilangan acak 1 hingga 6
        dadu1= randGen.nextInt(6) + 1;
        dadu2= randGen.nextInt(6) + 1;
    }
 
} // akhir kelas PasanganDadu

Contoh lain adalah kelas Murid yang digunakan pada bagian sebelumnya. Kita tambahkan variabel instansi nomorMurid yaitu nomor unik yang berbeda untuk setiap murid. Untuk itu kita perlu melacak nomor baru yang belum dipakai dengan variabel nomorBerikutnya yang berbentuk variabel statik sehingga semua objek akan mengacu pada variabel yang sama. Ketika objek baru dibuat, objek baru akan mengambil nilai nomorBerikutnya untuk dijadikan nomorMurid yang baru.

public class Murid {
 
    private String nama;  // Nama murid
    private int nomorMurid;  // nomor murid unik
    public double ujian1, ujian2, ujian3;   // Nilai ujian
 
    private static int nomorBerikutnya = 0;
    // simpan nomor murid berikutnya
 
    Murid(String namaBaru) {
        // Konstruktor objek Murid:
        // memberi nama, dan memberi nomor murid baru
        nama = namaBaru;
        nomorBerikutnya++;
        nomorMurid = nomorBerikutnya;
    }
 
    public String getNama() {
        // Fungsi untuk mengambil isi variabel instansi private: nama
        return nama;
    }
 
    public int getNomorMurid() {
        // Fungsi untuk membaca isi nomorMurid
        return nomorMurid;
    }
 
    public double hitungRataRata() {
        // Hitung rata-rata nilai ujian
        return (ujian1 + ujian2 + ujian3) / 3;
    }
 
}  // akhir kelas Murid

Inisialisasi "nomorBerikutnya = 0" hanya dilakukan satu kali, yaitu ketika kelas ini pertama kali dipanggil (pada saat program dijalankan). Ketika objek baru bertipe Murid dibuat, dan di dalam konstruktor perintah "nomorBerikutnya++;", maka nomor berikutnya akan disimpan untuk digunakan pada objek baru lainnya.

Ketika objek pertama dibuat, nilai nomorBerikutnya akan bernilai 1. Ketika objek kedua dibuat, nilai nomorBerikutnya bernilai 2, dan seterusnya. Konstruktor akan menyimpan nilai baru nomorBerikutnya pada variabel instansinya sendiri yang tidak di-share dengan objek-objek lain yaitu nomorMurid. Dengan cara ini setiap murid baru akan selalu memiliki nomorMurid baru yang berbeda satu dengan yang lain.

Read More

Variabel this dan super

Variabel spesial this dan super
Anggota statik suatu kelas bisa digunakan langsung di dalam kelas tersebut. Untuk digunakan di kelas lain, maka ia harus dipanggil dengan nama lengkapnya dalam bentuk "namaKelas.namaAnggota", misalnya "System.out" adalah variabel anggota statik dengan nama "out" di dalam kelas "System". Kita bisa menggunakan nama lengkap kelas tersebut di manapun, bahkan dari dalam kelas yang sama, misalnya karena nama anggota tersebut disembunyikan oleh variabel lokal yang namanya sama.

Variabel dan metode instansi juga bisa digunakan langsung di dalam kelas tersebut, misalnya suatu variabel instansi bisa digunakan langsung oleh metode instansi di kelas yang sama. Anggota instansi juga memiliki nama lengkap akan tetapi ingat bahwa anggota instansi dimiliki oleh objek, bukan kelas. Sehingga untuk memanggil suatu anggota instansi, kita harus menggunakan nama objek yang diciptakan dari kelas tersebut, dalam bentuk namaObjek.namaAnggota.

Akan tetapi, misalnya kita sedang menulis metode instansi di suatu kelas. Bagaimana caranya kita memanggil anggota instansi kelas yang sama jika kita belum tahu nama objek apa yang diciptakan dari kelas ini?

Java memiliki variabel spesial yang dinamakan "this" yang bisa digunakan untuk kasus di atas. Variabel ini digunakan pada suatu objek untuk memanggil metode atau variabel instansi pada objek yang sama. Maksudnya, this, merujuk pada "objek ini" yaitu objek di mana metode sedang dijalankan. Jika x adalah variabel instansi dalam suatu objek, maka this.x adalah nama lengkap variabel tersebut jika dipanggil dari dalam objek yang sama. Jika metode suatuMetode() adalah metode instansi pada suatu objek, maka this.suatuMetode() bisa digunakan untuk memanggil metode tersebut dari objek yang sama. Ketika komputer menjalankan perintah tersebut, komputer akan mengganti variabel this dengan objek yang berjalan pada saat itu.

Salah satu kegunaaan this adalah pada konstruktor, misalnya :

public class Murid {
    private String nama;  // Nama murid
 
    public Murid(String nama) {
        // Konstruktor, membuat murid dengan nama yang diberikan
        this.nama = nama;
    }
    .
    .   // Variabel dan metode lain.
    .
}

Dalam konstruktor di atas, variabel instansi nama disembunyikan oleh parameter formal yang bernama sama. Akan tetapi, variabel instansi masih tetap bisa dipanggil dengan nama lengkapnya, this.nama. Cara ini merupakan cara yang lazim, artinya kita tidak perlu mengganti nama parameter formal dengan nama lain agar namanya tidak bentrok dengan nama salah satu variabel instansinya. Kita bisa menggunakan nama parameter formal yang sama persis dengan variabel instansinya.

Ada lagi kegunaan lain dari this. Ketika kita sedang menulis metode instansi, kita ingin memberikan objek sebagai parameter aktual. Dalam hal ini, kita bisa menggunakan this sebagai parameter aktualnya. Misalnya, kita ingin mencetak suatu objek sebagai string, kita bisa menggunakan perintah "System.out.println(this);". Atau kita ingin mengisi nilai this ke dalam variabel lain. Pokoknya, kita bisa melakukan segala hal seperti layaknya variabel kecuali mengganti isinya.

Java juga memiliki variabel spesial yang dinamakan "super" untuk digunakan dalam metode instansi. Variabel super digunakan dalam kelas turunan. super mengacu pada objek di mana metode tersebut berada, akan tetapi ia merupakan bagian dari kelas super dari objek tersebut.

Suatu kelas bisa ditambah atau dimodifikasi dari kelas turunannya. Variabel super hanya mengacu pada bagian objek sebelum ia ditambah atau dimodifikasi, atau dengan kata lain bentuk aslinya sebelum dia diturunkan, yang dalam hal ini sama dengan kelas supernya.

Misalnya kita akan menulis suatu kelas, dan kelas tersebut memiliki metode instansi bernama suatuMetode(). Pernyataan super.suatuMetode() berarti menjalankan suatuMetode() pada kelas supernya. Jika tidak ada metode sutuMetode() pada kelas supernya, Java akan menampilkan pesan kesalahan sintaks.

Alasan mengapa Java memiliki variabel super adalah karena banyak hal yang mungkin tersembunyi pada kelas turunan. Misalnya karena kita mengimplementasikan fungsi lain pada kelas turunan dengan nama yang sama (dalam kaitannya dengan polimorfisme, misalkan).

Ketika kita membuat metode baru pada kelas turunan yang memiliki nama dan jenis parameter yang sama dengan metode pada kelas supernya, metode dari kelas super akan disembunyukan. Dalam bahasa pemrograman, metode ini menimpa (override) metode dari kelas supernya. Variabel super bisa digunakan untuk mengakses metode aslinya yang didefinisikan di kelas supernya.

Kegunaan utama dari super biasanya untuk memperluas kegunaan metode yang sudah ada, bukan menggantinya secara keseluuruhan. Metode baru bisa menggunakan super untuk menjalankan instruksi pada kelas supernya, kemudian menambahkan instruksi lain pada kelas turunannya.

Misalnya, kita memiliki kelas PasanganDadu yang memiliki metode kocok. Kemudian kita akan membuat kelas turunan yaitu DaduGrafis yang berfungsi untuk menggambar dadu pada layar. Metode kocok() dalam DaduGrafis harus melakukan apa yang dilakukan oleh PasanganDadu, dengan tambahan perintah untuk menggambar dadu tersebut di layar. Kita bisa tulis definisi kelas DaduGrafis dalam bentuk :

public class DaduGrafis extends PasanganDadu {
    public void kocok() {
        // Mengocok dadu, kemudian menggambarnya di layar
        super.kocok();  // Panggil metode kocok() di kelas PasanganDadu
        gambar();      // Gambar ulang dadu
    }
    .
    .  // Metode dan variabel lain, termasuk metode gambar()
    .
}

Dengan cara ini kita bisa memperluas apa yang dilakukan oleh metode kocok() pada kelas supernya tanpa mengetahui dengan detail apa yang dilakukan langkah per langkah di kelas supernya.

Konstuktor pada Kelas Turunan

Konstruktor tidak bisa diturunkan, artinya jika kita membuat kelas turunan dari suatu kelas, konstruktor pada kelas supernya tidak termasuk bagian yang diturunkan. Jika kita ingin konstruktor tersebut pada kelas turunannya, maka kita harus membuat kembali konstruktor tersebut di kelas yang baru. Jika tidak, maka Java akan membuat konstruktor standar tanpa parameter apa-apa.

Hal ini mungkin menjadi masalah jika konstruktor pada kelas supernya melakukan banyak tugas. Artinya kita harus mengulang kembali menuliskan semua instruksi pada kelas supernya di kelas turunan yang baru. Masalahnya akan lebih rumit jika kita tidak mengetahui sama sekali apa yang dilakukan kelas supernya, misalnya apabila tidak ada kode sumbernya.

Cara yang paling mudah adalah menggunakan super. Di baris pertama konstruktor baru kita di kelas turunannya, kita bisa menggunakan super untuk memanggil konstruktor kelas supernya. Sintaksnya sedikit aneh dan membingungkan, dan hanya bisa digunakan untuk satu situasi saja : Sintaksnya mirip seperti memanggil subrutin super (meskipun sebenarnya super bukan subrutin dan kita tidak bisa memanggil konstruktor seperti kita memanggil subrutin biasa).

Misalnya kelas PasanganDadu memiliki konstruktor yang memiliki dua parameter bertipe int. Maka kita bisa membuat konstruktor pada kelas DaduGrafis seperti :

public class DaduGrafis extends PasanganDadu {
 
    public DaduGrafis() {  // Konstruktor kelas ini
        super(3,4);  // Panggil konstruktor dari kelas PasanganDadu
                     // dengan parameter 3 dan 4
        inisialisasiGrafis();  // Lakukan inisialisasi grafis
                               // untuk digunakan pada kelas DaduGrafis
    }
    .
    .  // Konstruktor, variabel dan metode instansi lain
    .
}

Read More

Pewarisan, Polimorfisme, dan Kelas Abstrak

Kelas melambangkan cetak biru objek yang memiliki kesamaan struktuk dan perilaku. Kelas menentukan struktur suatu objek melalui variabel yang terkandung dalam setiap objek, dan menentukan perilaku melalui metode instansi yang merupakan perilaku suatu objek.

Ide utama dari pemrograman berorientasi objek -- yang membedakannya dari pemrograman tradisional -- adalah menciptakan kelas yang memiliki hanya beberapa (tidak semua) struktur dan perilaku. Kemiripan ini diekspresikan dalam bentuk pewarisan dan polimorfisme (perubahan bentuk).

Istilah pewarisan berarti suatu kelas bisa mewariskan sebagian atau keseluruhan struktur dan perilaku kelas lain. Jika kelas B adalah kelas turunan dari kelas A, maka kita bisa juga menyebut kelas A adalah kelas super dari kelas B. Kelas turunan bisa memiliki struktur atau perilaku tambahan dari kelas supernya. Atau bahkan kelas turunan bisa mengubah atau mengganti perilaku kelas supernya. Hubungan antara kelas turunan dan kelas super sering dilukiskan dalam bentuk diagram di mana kelas turunan digambarkan di bawah kelas supernya, dan dihubungkan dengan garis penghubung dengan tanda segitiga yang diletakkan di dekat kelas supernya.

Dalam bahasa Java, ketika kita membuat suatu kelas, kita bisa menyatakan bahwa kelas tersebut merupakan kelas turunan dari kelas lain. Jika kita buat kelas yang bernama "B" dan kita ingin kelas ini menjadi kelas turunan dari kelas "A", kita akan tulis dalam bentuk :

class B extends A {
    .
    .  // tambahan atau perubahan
    .  // struktur dan perilaku dari kelas A
    .
}

Beberapa kelas dapat menurunkan kelas yang sama. Kelas-kelas turunan ini masing-masing disebut kelas saudara, yaitu diwariskan dari satu kelas super yang sama. Struktur dan perilaku kelas super ini akan dimiliki oleh masing-masing turunannya. Pada diagram berikut, kelas B, C, dan D adalah kelas saudara. Pewarisan juga bisa dilakukan beberapa kali, atau suatu kelas bisa memiliki cucu, buyut, dan seterusnya. Pada diagram, kelas E merupakan kelas turunan kelas D, sehingga kelas E adalah "cucu" dari kelas A. Kelas E masih bisa disebut turunan dari kelas A, walaupun bukan merupakan turunan langsungnya.

Mari kita buat sebuah contoh. Kita akan membuat program yang berhubungan dengan kendaraan bermotor, yang meliputi mobil, truk, dan motor. Program tersebut memiliki kelas yang dinamakan Kendaraan yang melambangkan semua  jenis kendaraan bermotor. Kelas Kendaraan memiliki variabel instansi seperti nomorPolisi dan pemilik dan metode instansi yang bernama gantiPemilik. Variabel dan metode instansi ini bisa digunakan oleh segala jenis kendaraan bermotor.

Ada 3 kelas turunannya yaitu Mobil, Truk dan Motor yang akan menyimpan variabel dan metode khusus untuk setiap jenis kendaraan. Kelas Mobil misalnya memiliki variabel jumlahPintu, kelas Truk memiliki variabel jumlahRoda, dan kelas Motor memiliki variabel jumlahTak. Kelas-kelas ini bisa dideklarasikan dalam Java dalam bentuk.

class Kendaraan {
    int nomorPolisi;
    Orang pemilik;  // (anggap kelas Orang telah dibuat sebelumnya)
    void gantiPemilik(Orang pemilikBaru) {
        . . .
    }
    . . .
}
 
class Mobil extends Kendaraan {
    int jumlahPintu;
    . . .
}
 
class Truk extends Kendaraan {
    int jumlahRoda;
    . . .
}
 
class Motor extends Kendaraan {
    int jumlahTak;  // 2-tak atau 4-tak
    . . .
}

Anggap mobilku adalah variabel dengan tipe Mobil akan dideklarasikan dan diinisialisasi dengan pernyataan berikut.

Mobil mobilku = new Mobil();

Dengan deklarasi seperti ini, maka program akan bisa mengakses mobilku.jumlahPintu, karena jumlahPintu adalah variabel instansi dari kelas Mobil. Akan tetapi karena kelas Mobil merupakan turunan dari kelas Kendaraan, maka mobil ini juga memiliki stuktur dan perilaku dari kendaraan. Artinya program juga bisa mengakses mobilku.nomorPolisi, mobilku.pemilik, dan menjalankan metode mobilku.gantiPemilik()
Dalam dunia nyata mobil, truk dan motor memang kendaraan (bukan hanya pada program). Dalam arti objek yang memiliki tipe Mobil atau Truk atau Motor juga secara otomatis objek bertipe Kendaraan. Fakta penting berikutnya :
Variabel yang dapat diisi referensi ke objek suatu kelas A juga dapat diisi referensi ke objek kelas turunan dari kelas A.
Efek praktis dari penyataan ini adalah, objek dengan tipe Mobil dapat diisi ke dalam variabel bertipe Kendaraan, atau dengan kata lain perintah berikut adalah valid.

Kendaraan kendaraanku = mobilku;

atau bahkan juga perintah berikut.

Kendaraan kendaraanku = new Mobil();

Setelah pernyataan di atas, variabel kendaraanku berisi referensi ke objek Kendaraan, yang kebetulan merupakan instansi dari kelas turunannya, yaitu kelas Mobil. Objek akan "mengingat" bahwa yang disimpan dalam variabel tersebut adalah objek bertipe Mobil, bukan Kendaraan. Informasi tentang objek apa yang disimpan pada memori ikut disertakan bersama objek tersebut, sehingga variabel yang bertipe Kendaraan akan tahu dengan pasti tipe objek yang dirujuknya. Kita juga dapat menguji jenis objek yang disimpan suatu variabel dengan menggunakan operator instanceof. Misalnya

if (kendaraanku instanceof Mobil) { ... }

menguji apakah objek yang dirujuk pada variabel kendaraanku merupakan objek bertipe Mobil.
Kebalikannya, pernyataan berikut tidak bisa dilakukan.

mobilku = kendaraanku;

karena kendaraanku bisa bertipe objek lain seperti Truk atau Motor. Apabila kita tahu persis bahwa kendaraanku bertipe Mobil, kita bisa menggunakan casting, untuk memberi tahu komputer untuk memperlakukan variabel kendaraanku memiliki tipe Mobil. Jadi kita bisa gunakan perintah.

mobilku = (Mobil)kendaraanku;

Atau kita juga bisa mengakses ((Mobil)kendaraanku).jumlahPintu. Mari kita gunakan kelas ini dalam program, dan kita ingin mencetak informasi yang sesuai dengan suatu kendaraan. Misalnya:

System.out.println("Data Kendaraan:");
System.out.println("Nomor polisi:  " + kendaraanku.nomorPolisi);
if (kendaraanku instanceof Mobil)
    System.out.println("Jenis kendaraan:  Mobil");
    Mobil m = (Mobil)kendaraanku;
    System.out.println("Jumlah pintu:  " + m.jumlahPintu);
}
else if (kendaraanku instanceof Truk) {
    System.out.println("Jenis kendaraan:  Truk");
    Truk t = (Truk)kendaraanku ;
    System.out.println("Jumlah roda:  " + t.jumlahRoda);
}
else if (kendaraanku instanceof Motor) {
    System.out.println("Jenis kendaraan:  Motor");
    Motor sm = (Motor)kendaraanku ;
    System.out.println("Jumlah tak:    " + sm.jumlahTak);
}

Lihat bahwa untuk setiap jenis objek, komputer akan menguji satu per satu tipe objek yang disimpan dalam kendaraanku. Jika kendaraanku[code] merujuk pada objek bertipe Truk maka casting [code](Mobil)kendaraanku akan menampilkan pesan kesalahan.

Contoh lain, mari kita buat program untuk menggambar suatu bentuk geometri pada layar. Misalnya bentuk geometri tersebut terdiri dari persegi panjang, oval, dan kotak bersudut lingkar dengan berbagai warna.

Kelas yang akan kita buat adalah PersegiPanjang, Oval, dan KotakLingkar. Ketiga kelas tersebut memiliki kelas super yang sama yang disebut BentukGeometris. Kelas BentukGeometris memiliki variabel instansi warna, lokasi, dan ukuran. Untuk mengganti warna kita bisa mengganti variabel instansi warna pada kelas ini, kemudian menjalankan metode instansi gambar() untuk menggambar bentuk tersebut dengan warna baru:

class BentukGeometris {
    Color warna;   // Warna suatu bentuk geometri
                   // (Kelas Color diimport dari paket java.awt)
 
    void setWarna(Color warnaBaru) {
        // Metode untuk mengganti warna
        warna = warnaBaru; // ganti nilai variabel instansi
        gambar(); // gambar ulang bentuk geometris ini, dengan warna baru
    }
 
    void gambar() {
        // metode untuk menggambar
        ? ? ?  // perintaha apa yang harus diletakkan di sini?
    }
 
    . . .          // variabel dan metode instansi lain
 
} // akhir kelas BentukGeometris

Sekarang metode gambar() mungkin menjadi serba salah. Masalahnya, setiap bentuk digambar dengan cara berbeda. Metode setWarna() dapat digunakan oleh semua bentuk. Lalu bagaimana komputer tahu bagaimana menggambar bentuk tersebut jika metode gambar() dipanggil? Mudahnya, kita bisa jawab dengan : Komputer akan menjalankan perintah gambar() dengan meminta bentuk tersebut untuk menggambar sendiri. Setiap objek bentuk tahu apa yang harus dilakukan untuk menggambar dirinya.

Dalam prakteknya, ini berarti setiap kelas turunan dari kelas BentukGeometris memiliki metode gambar() sendiri-sendiri, yaitu :

class PersegiPanjang extends BentukGeometris {
    void gambar() {
        . . .  // perintah untuk menggambar persegi panjang
    }
    . . . // metode atau variabel lain
}
 
class Oval extends BentukGeometris {
    void gambar() {
        . . .  // perintah untuk menggambar oval
    }
    . . . // metode atau variabel lain
}
 
class KotakLingkar extends BentukGeometris {
    void gambar() {
        . . .  // perintah untuk menggambar kotak bersudut lingkar
    }
    . . . // metode atau variabel lain
}

Jika gambarku adalah variabel bertipe BentukGeometri, variabel ini bisa merujuk pada objek dengan bertipe PersegiPanjang, Oval, atau KotakLingkar. Ketika program dijalankan, isi variabel gambarku akan berubah-ubah, tergantung pada objek yang dirujuknya. Suatu saat di tengah program, jika perintah gambarku.gambar() dijalankan, maka metode gambar() akan dijalankan tergantung pada isi variabel gambarku saat itu.

Kita tidak akan bisa menebak metode apa yang akan dipanggil pada suatu saat hanya dengan membaca program tersebut, karena kita tidak pernah tahu isi variabel gambarku pada suatu saat tertentu. Misalnya perintah gambar() berada dalam suatu perulangan yang dijalankan berkali-kali. Maka akan sangat mungkin perintah gambarku.gambar() dipanggil berulang-ulang tetapi dengan objek yang berbeda-beda.

Kita sebut metode gambar() bersifat polimorfis. Suatu metode disebut polimorfis jika aksi yang dilakukan oleh suatu metode berbeda-beda tergantung pada objek aktual pada saat metode itu dijalankan. Polimorfisme adalah fitur utama dalam pemrograman berorientasi objek.

Mungkin akan lebih mudah dimengerti jika kita ganti bahasanya : Dalam PBO, memanggil metode sering disebut juga dengan mengirim pesan kepada suatu objek. Objek tersebut merespon pesan tersebut dengan melaksanakan metode yang sesuai. Pernyataan "gambarku.gambar();" adalah pesan yang dikirim ke objek gambarku. Karena objek tersebut tahu jenis objeknya sendiri, dia akan tahu bagaimana merespon pesan tersebut. Dari sudut pandang ini, komputer akan selalu mengeksekusi perintah "gambarku.gambar();" dengan cara yang sama, yaitu dengan mengirim pesan. Pesan tersebut bergantung pada siapa yang menerima pesan tersebut.

Dengan kata lain, objek merupakan sesuatu yang memiliki perilaku aktif, yaitu sesuatu yang bisa mengirim dan menerima pesan. Polimorfisme dianggap sebagai sifat yang natural jika dilihat dari sudut pandang ini. Polimorfisme juga berarti bahwa beberapa objek dapat merespon suatu pesan dengan cara yang berbeda-beda.

Salah satu keindahan dari poliformisme adalah kita bisa membuat kode program tanpa harus mengetahui persis apa yang akan dilakukan program saat kita menulis program tersebut. Jika kita ingin menambah objek lain, misalnya segitiga, maka kita cukup menulis kelas turunan baru dan membuat metode gambar() sendiri. Secara otomatis, program akan tahu jika kita beri perintah "gambarku.gambar()" maka metode gambar() pada kelas segitiga akan dijalankan apabila gambarku menunjuk pada objek yang memiliki kelas segitiga.

Ketika suatu objek, misalnya PersegiPanjang, Oval, atau KotakLingkar, harus menggambar dirinya sendiri, metode gambar() yang sesuai dengan objek yang menerima pesan akan dilaksanakan. Pertanyaannya, apa yang harus kita isi pada metode gambar() di kelas BentukGeometri?

Jawabannya: kosongkan saja. Intinya kelas BentukGeometri adalah kelas abstrak, karena tidak ada cara untuk menggambar BentukGeometri. Apabila kelas tersebut telah direalisasikan dalam suatu bentuk, misalnya PersegiPanjang, barulah objek tersebut bisa menggambar sesuatu.

Lalu kenapa kita harus mendeklarasikan metode gambar() di kelas BentukGeometri? Jawabannya, itu harus ada karena metode ini dibutuhkan untuk memanggil metode setWarna() pada kelas BentukGeometri. Program kita akan menampilkan pesan kesalahan jika kita berikan perintah gambarku.gambar(), karena gambarku bertipe BentukGeometri, apabila di dalam kelas ini tidak ada metode yang bernama gambar().

Kita bisa menyebut kelas BentukGeometri merupakan kelas abstrak. Kelas abstrak adalah kelas yang tidak bisa digunakan untuk membuat suatu objek, dan hanya digunakan untuk membuat kelas turunan. Kelas abstrak hanya ada untuk mengekspresikan sifat umum yang dimiliki oleh kelas-kelas turunannya.

Demikian juga, kita bisa menyebut metode gambar() pada kelas BentukGeometri merupakan metode abstrak, karena metode ini bukan untuk dipanggil. Akan tetapi metode ini ada untuk memberi tahu komputer bahwa semua kelas turunannya mengerti dan bisa menjalankan metode gambar().

BentukGeometri dan metode gambar() secara sematik merupakan kelas dan metode abstrak. Kita juga bisa memberi tahu komputer secara langsung dengan memberi sifat "abstract" pada definisinya. Untuk metode abstrak, blok perintahnya diganti dengan titik koma (;). Metode ini harus diimplementasikan secara detail pada kelas turunannya.

Perhatikan contoh berikut.

abstract class BentukGeometri {
    Color warna;
 
    void setWarna(Color warnaBaru) {
        // metode untuk mengganti warna suatu bentuk
        warna = warnaBaru; // ganti isi variabel instansi warna
        gambar(); // menggambar kembali suatu bentuk dengan warna baru
    }
 
    abstract void gambar();
        // metode abstrak yang harus diimplementasikan
        // pada kelas turunannya
 
        . . .          // variabel dan metode instansi lainnya
 
} // akhir kelas BentukGeometri

Setelah kita buat seperti ini, kita tidak bisa lagi membuat objek langsung dari kelas BentukGeometri.

Dalam Java, setiap kelas yang kita buat akan memiliki kelas super, atau dengan kata lain setiap kelas merupakan turunan dari kelas lain. Jika kita tidak memberi kelas supernya (melalui operator extends), maka kelas tersebut otomatis memiliki kelas super Object, yaitu kelas bawaan yang sudah didefinisikan dalam paket java.lang. Kelas Object adalah satu-satunya kelas yang tidak memiliki kelas super.

Jadi dengan demikian, perintah,

class Kelasku { ... }

sama artinya dengan

class Kelasku extends Object { . . . }

Semua kelas akan merupakan turunan langsung atau tidak langsung dari kelas Object. Artinya suatu obek yang merupakan kelas apapun dapat direferensikan oleh variabel bertipe Object. Kelas Objek memiliki sifat-sifat umum yang dapat digunakan oleh semua objek. Kelas Object adalah kelas yang paling abstrak dari kelas-kelas lainnya.

Kelas Object digunakan dalam beberapa kasus di mana kumpulan objek yang sangat umum ingin diolah. Misalnya, Java memiliki kelas standar java.util.ArrayList yang merupakan kumpulan Objects. ArrayList akan dibahas kemudian dalam topik tentang struktur data dan algoritma. Kelas ini digunakan untuk menampung kumpulan objek, tak ditentukan jumlahnya, dan bisa diperbanyak ketika objek baru ditambahkan. Objek yang dapat ditampung pada dasarnya adalah semua objek dari beragam kelas.

Kita dapat juga membuat program untuk menampung semua BentukGeometri yang telah digambar di layar dalam kontainer ArrayList. Milsanya ArrayList kita bernama kumpulanGambar. Suatu objek dengan tipe BentukGeometri misalnya gambarku dapat ditambahkan ke dalam kumpulan ini dengan menggunakan perintah "kumpulanGambar.add(gambarku);". Gambar tersebut dapat dibuang dari dalam kumpulan dengan perintah "kumpulanGambar.remove(gambarku);". Jumlah obejk dalam kumpulanGambar dapat diubah dengan perintah "kumpulanGambar.size()". Juga kita bisa mengambil gambar ke-n dari dalam kumpulanGambar dengan perintah "kumpulanGambar.get(n);". Perlu diingat bahwa metode tersebut akan mengembalikan objek bertipe Object bukan BentukGeometri, dan sebetulnya kontainer ini bisa menampung objek apa saja, bukan hanya BentukGeometri, sehingga untuk mengambil objek ke-n yang kemudian kita letakkan dalam variabel bertipe BentukGeometri, kita bisa gunakan perintah.

gambarku = (BentukGeometri)kumpulanGambar.get(n);

Katakan misalnya kita ingin menggambar semua objek dengan berbagai tipe di dalam kumpulan tersebut, kita bisa gunakan perulangan for sederhana (sekaligus memberi contoh betapa indagnya PBO dan polimorfisme), yaitu dengan :

for (int n = 0; n < kumpulanGambar.size(); n++) {
    BentukGeometri bg = (BentukGeometri)kumpulanGambar.get(n);
    bg.gambar();
}

Tambahan

Dalam pemrograman sehari-hari, terutama bagi programmer yang baru belajar dan bekerja dengan objek, penurunan kelas akan sering digunakan. Salah satunya adalah untuk memperluas kegunaan suatu kelas, yang disesuaikan dengan situasi dan kondisi permasalahan yang kita hadapi. Kita bisa membuat kelas baru yang merupakan turunan kelas yang sudah ada, menambah beberapa variabel dan metode instansi baru, yaitu dengan operator extends seperti dijelaskan sebelumnya pada bagian ini.

Secara umum, sintaksnya adalah dalam bentuk

class kelas_turunan extends kelas_yang_sudah_ada {
   ... // tambahan atau perubahan variabel dan metode instansi
}

Kita akan lihat nanti bahwa banyak kelas-kelas standar pada Java yang digunakan hanya sebagai kelas dasar yang untuk dikembangkan lebih jauh oleh kita sebagai programmer.

Read More