Pada contoh-contoh sebelumnya dan beberapa penjelasannya, kita telah menyinggung beberapa kali tentang class (kelas) dan object (obyek). Namun kita belum memahami dengan jelas apa sebenarnya kelas dan obyek dalam Java. Kelas dan obyek dalam Java adalah penerapan dari prinsip-prinsip pemrograman berorientasi obyek yang telah kita pahami pada awal label ini.
Kelas dapat didefinisikan sebagai kerangka yang mendefinisikan variabel-variabel method umum dari sebuah obyek tertentu. Pada pemrograman berorientasi obyek, kelas tidak jauh berbeda dengan tipe data primitive. Perbedaannya, tipe data digunakan untuk mendeklarasikan variabel normal, sedangkan kelas digunakan untuk mendeklarasikan variabel yang berupa obyek. Dan kelas, masih bersifat abstrak.
Pembuatan kelas
Pada java, kelas didefinisikan dengan kata kunci class. Bentuk umum untuk mendefinisikan kelas adalah sebagai berikut:class NamaKelas
tipe data1;
tipe data2;
…
tipe dataN;
tipe method1 (daftar parameter) {
//blok kode untuk method1
}
tipe method2 (daftar parameter) {
//blok kode untuk method2
}
…
tipe methodN (daftar parameter) {
//blok kode untuk methodN
}
}
Data atau variabel yang didefinisikan di dalam kelas sering disebut sebagai instance variable. Nilai-nilai variabel ini akan dibaca melalui method-method yang tersedia. Dengan demikian method digunakan sebagai antarmuka (interface) antara pemakai kelas, dengan data yang ada di dalam kelas tersebut. Perhatikan contoh kelas berikut.
Contoh 8.22. Membuat kelas sederhana.
class Siswa
{
String name;
String alamat;
int usia;
}
Pada kode di atas kita membuat class dengan nama Siswa. Ada tiga data yang ada pada class tersebut yaitu: nama, alamat, dan usia. Kita belum menambahkan method di sini. Melalui kode di atas sebenarnya kita telah mendefinisikan tipe data baru, yaitu: Siswa. Kode program di atas hanyalah sebuah template. Artinya, kalau menjalankan program di atas tidak akan menghasilkan apa-apa. Kita perlu membuat obyek aktual berdasarkan kelas di atas dengan cara sebagai berikut.
Contoh 8.23. Menggunakan kelas.
class Siswa {
String nama;
String alamat;
int usia;
}
public class DataSiswa {
public static void main(String[] args) {
Siswa siswa1 = new Siswa();
siswa1.nama = "Roni";
siswa1.alamat = "Mergosono Gg. 1 No. 34";
siswa1.usia = 23;
System.out.println("Nama :" + siswa1.nama);
System.out.println("Alamat :" + siswa1.alamat);
System.out.println("Usia :" + siswa1.usia);
}
}
Kode program di atas harus kita simpan dengan nama file 'DataSiswa.java', bukan 'Siswa.java'. Hal ini karena method main berada pada class DataSiswa. Pada kode di atas, kelas Siswa kita gunakan pada kelas DataSiswa. Kita membuat obyek aktual dari kelas Siswa dengan cara mengetikkan Siswa siswa1 = new Siswa();. Siswa1 adalah nama obyek aktual dari kelas Siswa. Setelah itu, baru kita dapat menggunakan variabel atau data yang ada pada kelas siswa. Kalau dijalankan, kode program di atas akan menghasilkan output seperti pada gambar 8.13.
Sekarang kita akan buat kelas menjadi sedikit lebih kompleks dengan mengikutkan method pada kelas tersebut. Perhatikan contoh berikut.
Contoh 8.23. Pembuatan kelas yang mempunyai method.
class Siswa {
String nama;
String alamat;
int usia;
double nilaiMatematika;
double nilaiBhsInggris;
double nilaiBhsIndonesia;
double rerata;
// Menghasilkan nama dari Siswa
public String getNama(){
return nama; }
// Mengubah nama siswa
public void setNama( String temp ){
nama = temp;
}
// Menghitung rata – rata nilai
public double getRerata(){
rerata = (
nilaiMatematika+nilaiBhsInggris+nilaiBhsIndonesia )/3;
return rerata;
}
}
public class DataSiswa {
public static void main(String[] args) {
Siswa siswa1 = new Siswa();
siswa1.setNama("Rony");
siswa1.nilaiMatematika = 67;
siswa1.nilaiBhsInggris = 87;
siswa1.nilaiBhsIndonesia = 59;
System.out.println("Nama :" +
siswa1.getNama());
System.out.println("Nilai Matematika :" +
siswa1.nilaiMatematika);
System.out.println("Nilai Bahasa Inggris :" +
siswa1.nilaiBhsInggris);
System.out.println("Nilai Bahasa Indonesia :" +
siswa1.nilaiBhsIndonesia);
System.out.println("Rerata :" +
siswa1.getRerata());
}
}
Pada kode di atas kita memperluas kelas Siswa dengan menambahkan empat variabel, yaitu: nilaiMatematika, nilaiBhsInggris, nilaiBhsIndonesia, dan rerata. Kita juga menambahkan tiga buah method, yaitu: getNama, setNama, dan getRerata. getNama merupakan method untuk menampilkan isi dari variabel nama. setNama adalah method untuk memberi nilai pada variabel nama. getRerata adalah method untuk menghitung rata-rata nilai dari tiga pelajaran, dan menampilkan isi dari hasil perhitungan. Perhatikan bagaimana method ini digunakan pada kelas DataSiswa. Apabila dijalankan, maka kita akan memperoleh output seperti pada gambar 8.14.
Ada beberapa tipe method di dalam class, yaitu: method yang tidak mengembalikan nilai, method yang mengembalikan nilai, dan method khusus yaitu constructor. Secara umum method ini boleh kita samakan dengan prosedur atau fungsi. Perhatikan contoh-contoh berikut ini.
Contoh 8.24. Pembuatan method tanpa pengembalian nilai.
Class Bangun {
double panjang;
double lebar;
// Mendefinisikan method void (tidak mengembalikan nilai)
void cetakLuas() {
System.out.println("Luas bangun = " +
(panjang * lebar));
}
}
class pakaiBangun {
public static void main(String[] args) {
Bangun b1, b2;
// instansiasi objek
b1 = new Bangun();
b2 = new Bangun();
// mengisi data untuk objek b1
b1.panjang = 4;
b1.lebar = 3;
// mengisi data untuk objek b2
b2.panjang = 6;
b2.lebar = 5;
// memanggil method cetakLuas() untuk masing-masing
objek
b1.cetakLuas();
b2.cetakLuas();
}
}
Pada kode di atas, class Bangun mempunyai satu method, yaitu: cetakLuas. Method ini tidak mengembalikan nilai. Hasil akhir dari method ini akan tersimpan pada method tersebut. Bandingkan dengan contoh berikut.
Contoh 8.25. Pembuatan method dengan pengembalian nilai.
Class Bangun {
double panjang;
double lebar;
// Mendefinisikan method yang mengembalikan nilai
double hitungLuas() {
double luas = panjang * lebar;
return luas;
}
}
class pakaiBangun {
public static void main(String[] args) {
Bangun b1, b2;
// instansiasi objek
b1 = new Bangun();
b2 = new Bangun();
// mengisi data untuk objek b1
b1.panjang = 4;
b1.lebar = 3;
// mengisi data untuk objek b2
b2.panjang = 6;
b2.lebar = 5;
// memanggil method hitungLuas() untuk masing-masing
objek
System.out.println("Luas b1 = " + b1.hitungLuas());
System.out.println("Luas b2 = " + b2.hitungLuas());
}
}
Pada contoh 8.25 ini kita membuat metode hitungLuas yang mengembalikan nilai. Perhatikan deklarasi method tidak lagi menggunakan void, tetapi menggunakan double yang merupakan tipe data nilai yang dikembalikan. Untuk mengembalikan nilai digunakan kata kunci return. Perhatikan cara pemanggilan method dari contoh 8.24 dan 8.25, apa yang berbeda?
Method dapat juga memiliki argumen seperti halnya pada fungsi atau prosedur. Perhatikan contoh berikut.
Contoh 8.26. Pembuatan method dengan argumen.
class Bangun {
double panjang;
double lebar;
// method dengan argumen
void isiData(double p, double l) {
panjang = p;
lebar = l;
}
// method yang mengembalikan nilai
double hitungLuas() {
double luas = panjang * lebar;
return luas;
}
}
class pakaiBangun {
public static void main(String[] args) {
Bangun b;
// instansiasi obyek
b = new Bangun();
// memanggil method isiData dan mengisi argumennya
b.isiData(6,8);
// memanggil method hitungLuas() untuk objek b
System.out.println("Luas b = " + b.hitungLuas());
}
}
Pada contoh 8.26 ini kita menambahkan satu method lagi pada class Bangun, yaitu: isiData. Karena tidak mengembalikan nilai, maka kita menggunakan void. Method ini mempunyai dua buah argument, yaitu: p dan l yang digunakan untuk menampung nilai yang akan kita masukkan. Perhatikan, bagaimana kita menggunakan method ini (lihat bagian b.isiData(6, 8) ).
Constructor yang merupakan method khusus merupakan method yang didefiniskan di dalam kelas dan akan dipanggil secara otomatis setiap kali terjadi pendefinisian (instansiasi) obyek. Biasanya, constructor berfungsi untuk melakukan inisialisasi nilai terhadap data-data yang terdapat pada kelas yang bersangkutan. Nama method constructor harus sama dengan nama kelas itu sendiri. Constructor tidak memiliki kembalian nilai dan tidak void. Perhatikan contoh berikut ini.
Contoh 8.27. Pembuatan class dengan constructor.
class Bangun {
double panjang;
double lebar;
// constructor dengan argumen
Bangun(double p, double l) {
panjang = p;
lebar = l;
}
// method yang mengembalikan nilai
double hitungLuas() {
double luas = panjang * lebar;
return luas;
}
}
class pakaiBangun {
public static void main(String[] args) {
Bangun b;
// instansiasi obyek
b = new Bangun();
// memanggil method isiData dan mengisi argumennya
b.isiData(6,8);
// memanggil method hitungLuas() untuk objek b
System.out.println("Luas b = " + b.hitungLuas());
}
}
Kode di atas sekilas sama dengan contoh 8.26, namun sebenarnya berbeda. Pada kode ini terdapat constructor dengan nama yang sama dengan kelasnya, yaitu: Bangun. Constructor seperti halnya method yang lain boleh mempunyai argumen dan boleh tidak. Pada contoh di atas, constructor Bangun mempunyai argumen p dan l.
Penerapan inheritance
Prinsip inheritance atau pewarisan, secara umum telah kita pahami pada awal label. Pewarisan adalah keuntungan besar dalam pemrograman beorientasi obyek karena suatu sifat atau method yang telah didefinisikan dalam superclass, secara otomatis diwariskan pada semua subclasses. Jadi kita mungkin hanya perlu mendefinisikan method satu kali di superclass, kemudian dapat kita gunakan pada subclass. Perhatikan contoh berikut.Contoh 8.28. Penerapan inheritance.
class SuperA {
private int a;
public void setSuperA(int nilai) {
a = nilai;
}
public int getSuperA() {
return a;
}
}
// membuat kelas turunan (subclass) dari kelas A
class SubB extends SuperA {
private int b;
public void setSubB(int nilai) {
b = nilai;
}
public int getSubB() {
return b;
}
}
class DemoKelasTurunan1 {
public static void main(String[] args) {
// melakukan instansiasi terhadap kelas B
SubB ObyekB = new SubB();
// mengeset nilai objek dari kelas B
ObyekB.setSuperA(50);
ObyekB.setSubB(200);
// mendapatkan nilai yang terdapat dalam objek dari
kelas B
System.out.println("Nilai a : " + Obyek.getSuperA());
System.out.println("Nilai b : " + Obyek.getSubB());
}
}
Pada kode di atas, class SuperA adalah super class yang memiliki satu data yaitu: a, dan dua method yaitu: setSuperA dan getSuperA. Class SubB adalah turunan dari kelas SuperA (perhatikan deklarasi class SubB extends SuperA). Data dan method yang ada pada class SuperA secara otomatis akan dibawa ke class SubB. Sehingga class SubB akan mempunyai dua data, yaitu: a dan b. Data a adalah hasil warisan dari class SuperA sedang data b adalah milik class SubB sendiri. Method pada class SubB akan terdiri dari empat method, yaitu: setSuperA dan getSuperA yang merupakan warisan dari class SuperA, serta class setSubB dan getSubB yang milik class SubB sendiri. Cobalah ketik program di atas, kemudian jalankan dan cermati hasil yang diperoleh.
Perhatikan contoh yang lain berikut ini.
Contoh 8.29. Penerapan inheritance untuk menghitung luas dan volume.
class Bangun {
protected double panjang;
protected double lebar;
// constructor default
Bangun() {
panjang = lebar = 0;
}
Bangun(double p, double l) {
panjang = p;
lebar = l;
}
// method yang mengembalikan nilai
public double hitungLuas() {
double luas = panjang * lebar;
return luas;
}
}
class Box extends Bangun {
private double tinggi;
// constructor class Box
Box (int p, int l, int t) {
panjang = p;
lebar = l;
tinggi = t;
}
public double getTinggi() {
return tinggi;
}
public double hitungVolume() {
double volume = panjang * lebar * tinggi;
return volume;
}
}
class inheritBangun {
public static void main(String[] args) {
Box kotak;
// instansiasi obyek
kotak = new Box(6, 8, 3);
// memanggil method hitungLuas(), getTinggi() dan
hitung volume()
System.out.println("Luas salah satu sisi = " +
kotak.hitungLuas());
System.out.println("Tinggi kotak = " +
kotak.getTinggi());
System.out.println("Volume kotak = " +
kotak.hitungVolume());
}
}
Kelas Bangun di atas adalah superclass, sedangkan Box adalah subclass. Pada default constructor Bangun, nilai panjang dan lebar diinisialisasi dengan nilai 0. Perhatikan didepan deklarasi variabel panjang dan lebar pada kelas Bangun dicantumkan kata kunci protected yang berarti kelas turunan dari Bangun tetap dapat mengakses nilai dari variabel tersebut, namun yang tidak memiliki hubungan turunan tidak dapat mengaksesnya.
Pada Box yang merupakan subclass ditambahkan satu variabel, yaitu: tinggi dengan tambahan kata kunci private diikuti tipe datanya. Private menunjukkan bahwa variabel tinggi hanya bisa diakses didalam kelas Box. Lawan dari private adalah public, yang berarti dapat diakses oleh siapapun dan dari manapun. Pada kelas Box, juga kita tambahkan satu method yaitu hitungVolume(). Pada contoh 8.29 di atas obyek yang kita buat yaitu kotak, yang merupakan hasil instansiasi dari kelas Box. Oleh karena kelas Box adalah turunan dari kelas Bangun, maka kita dapat mengakses method hitungLuas() yang merupakan warisan dari kelas Bangun. Tentu saja, kita bisa mengakses method getTinggi() dan hitungVolume() yang merupakan method pada kelas Box. Kalau kita eksekusi program di atas, maka akan tampak seperti berikut.
Penerapan overriding dan overloading
Kadang-kadang, ketika kita membuat method di dalam subclass, kita ingin membuat method dengan nama yang sama dengan method pada superclass namun dengan penerapan yang berbeda. Sebagai contoh pada kelas Bangun pada contoh 8.29, tersedia method hitungLuas(). Misalnya kita ingin membuat subclass Segitiga yang merupakan turunan dari kelas Bangun. Kemudian kita ingin membuat method hitungLuas() yang penerapannya tidak lagi luas = panjang x lebar tetapi dengan penerapan luas = 0.5 x alas x tinggi. Pada kondisi ini method hitungLuas() dari superclass akan tertutupi oleh method pada subclass. Hal seperti ini biasa disebut sebagai overriding. Perhatikan contoh berikut.Contoh 8.30. Penerapan overriding.
class Bangun {
// method umum
public double hitungLuas() {
System.out.println("Method belum terdefinisi");
Return 0;
}
}
class Segitiga extends Bangun {
private double alas;
private double tinggi;
Segitiga (int a, int t) {
alas = a;
tinggi = t;
}
// overriding method hitungLuas()
public double hitungLuas() {
double luas = 0.5 * alas * tinggi;
return luas;
}
}
class overridingBangun {
public static void main(String[] args) {
Segitiga s;
// instansiasi obyek
s = new Segitiga(6, 8);
// memanggil method hitungLuas() dari subclass Segitiga
System.out.println("Luas segitiga = " +
s.hitungLuas());
}
}
Pada contoh di atas, kelas Bangun sebagai superclass mempunyai method hitungLuas(), tetapi belum kita definisikan isi methodnya. Pada kelas Segitiga, method hitungLuas() ini kita overriding untuk mendapatkan nilai luas segitiga. Pada eksekusi program di atas, yang dijalankan adalah method hitungLuas() yang ada pada subclass Segitiga. Hasil dari eksekusi program akan tampak seperti pada gambar 8.16. Apabila kita ingin tetap menjalankan method hitungLuas() yang ada pada kelas Bangun, kita dapat memanggil dengan kata kunci super. Rubahlah method hitungLuas() pada kelas Segitiga dengan kode berikut.
public double hitungLuas() {
super.hitungLuas();
System.out.println();
double luas = 0.5 * alas * tinggi;
return luas;
}
Jalankan program, maka kita akan mendapatkan hasil seperti gambar 8.17. Bandingkan dengan hasil eksekusi sebelumnya (gambar 8.16)
Overloading memiliki kesamaan dengan overriding dalam hal menyembunyikan method dari superclass. Tetapi memiliki perbedaan, yaitu: pada overloading methodnya memiliki nama yang sama dengan method pada kelas induk, tetapi memiliki daftar argument dan implementasi yang berbeda. Sedangkan overriding, method mempunyai nama dan daftar argumen yang sama dengan kelas induk dan hanya implementasinya yang berbeda. Perhatikan contoh berikut.
Contoh 8.31. Contoh overloading.
class Bangun {
// method umum
public double hitungLuas() {
System.out.println("Method belum terdefinisi");
return 0;
}
}
class BujurSangkar extends Bangun {
private double sisi;
// overload method hitungLuas()
public double hitungLuas(double sisi) {
double luas = sisi * sisi;
return luas;
}
}
class overloadBangun {
public static void main(String[] args) {
BujurSangkar b;
// instansiasi obyek
b = new BujurSangkar();
// memanggil method hitungLuas() dari subclass
BujurSangkar
System.out.println("Luas BujurSangkar = " +
b.hitungLuas(6));
}
}
Perhatikan pada kode di atas, method hitungLuas() pada kelas bangun tidak mempunyai argumen sedangkan pada kelas BujurSangkar mempunyai argumen yaitu sisi. Inilah yang disebut sebagai overloading. Bandingkan dengan contoh overriding pada contoh 8.29 dan 8.30.
Penerapan polymorphism
Seperti telah dijelaskan di awal label, polymorphism adalah sebuah kemampuan sebuah menerjemahkan suatu method menjadi berbagai macam aksi. Sebenarnya ketika kita memahami overriding dan overloading di atas, secara tidak langsung kita telah mempelajari dasar-dasar menyusun teori polymorphism. Polymorphism membolehkan kelas induk (superclass) untuk mendefinisikan method umum untuk semua turunannya. Kelas-kelas turunannya dapat mengimplementasikan method tersebut sesuai dengan karakteristik masin-masing kelas.Pada contoh 8.30 dan 8.31 kita telah membuat kelas Bangun yang merupakan kelas induk yang mempunyai method hitungLuas(). Method ini bersifat umum. Pada contoh 8.30, method ini kita implementasikan dengan untuk mencari nilai luas segitiga pada kelas Segitiga. Sedangkan pada contoh 8.31, method ini kita implementasikan untuk mencari luas BujurSangkar pada kelas BujurSangkar. Perhatikan contoh berikut ini.
Contoh 8.32. Penerapan polymorphism.
class Bangun {
public double hitungLuas() {
System.out.println("Method umum");
return 0;
}
}
class BujurSangkar extends Bangun {
private double sisi;
BujurSangkar(int s) {
sisi = s;
}
//overriding method hitungLuas()
public double hitungLuas() {
double luas = sisi * sisi;
return luas;
}
}
class Segitiga extends Bangun {
private double alas;
private double tinggi;
Segitiga (int a, int t) {
alas = a;
tinggi = t;
}
// overriding method hitungLuas()
public double hitungLuas() {
double luas = 0.5 * alas * tinggi;
return luas;
}
}
class Lingkaran extends Bangun {
private double jarijari;
private final double PI = 3.1416;
Lingkaran(int r) {
jarijari = r;
}
//overriding method hitungLuas()
public double hitungLuas() {
double luas = PI * jarijari * jarijari;
return luas;
}
}
class DemoPolimorfisme2 {
public static void main(String[] args) {
Bentuk obyek;
BujurSangkar b = new BujurSangkar(12);
Segitiga s = new Segitiga(5, 6);
Lingkaran l = new Lingkaran(4);
// obyek mengacu pada objek BujurSangkar
obyek = b;
// akan memanggil method yang terdapat pada
BujurSangkar
System.out.println("Luas bujursangkar : " +
obyek.hitungLuas());
System.out.println();
// obyek mengacu pada objek Segitiga
obyek = s;
// akan memanggil method yang terdapat pada Segitiga
System.out.println("Luas segitiga : " +
obyek.hitungLuas());
System.out.println();
// obyek mengacu pada objek Lingkaran
obyek = l;
// akan memanggil method yang terdapat pada Lingkaran
System.out.println("Luas lingkaran: " +
obyek.hitungLuas());
System.out.println();
}
}
Pada contoh 8.32 ini kita menggabungkan contoh-contoh sebelumnya untuk menunjukkan bagaimana polymorphism terbentuk. Kelas induk adalah Bangun dan mempunyai subclass yaitu: BujurSangkar, Segitiga, dan Lingkaran. Semua subclass mempunyai method hitungLuas() yang diturunkan dari kelas Bangun. Perhatikan, bahwa meskipun nama method hitungLuas() ada pada semua subclass, ternyata penerapannya berbeda-beda tergantung pada subclass masing-masing.
Menggunakan paket dan interface
Pada beberapa postingan yang lalu telah disinggung tentang package atau paket. Packages dalam JAVA berarti pengelompokan beberapa class dan interface dalam satu unit. Fitur ini menyediakan cara untuk mengatur class dan interface dalam jumlah banyak, dan menghindari kekacauan pada penamaan class dan file.Kalau kita cermati contoh 8.4 pada sub label terdahulu, sebenarnya kita telah menggunakan konsep package ini secara tidak langsung. Pada contoh tersebut kita menggunaka pernyataan import untuk menggunakan kelas-kelas yang ada pada paket Java.IO. Java menyediakan banyak paket yang telah dibuat oleh tim pengembang java. Paket-paket ini dapat kita gunakan untuk mempermudah pemrograman.
Cara membuat paket cukup mudah, kita tinggal menggunakan kata kunci package diikuti dengan nama paket yang kita inginkan atau seperti berikut:
package NamaPaket;
NamaPaket adalah nama paket yang kita akan gunakan untuk menyimpan file kode program dan file hasil kompilasi. Java menggunakan sistem direktori untuk menyimpan paket yang dibuat. Apabila kita membuat paket dengan nama PaketBangun, maka kita harus membuat direktori dengan nama yang sama persis yaitu PaketBangun. Dan file paket serta kelas-kelas dalam satu paket tersebut harus kita simpan pada direktori tersebut. Perhatikan contoh berikut.
Contoh 8.33. Pembuatan paket.
Pada halaman ini kita akan membuat paket yang merupakan modifikasi dari contoh 8.32. Nama paket yang ingin kita buat adalah PaketBangun yang mempunyai tiga anggota kelas yaitu: kelas BujurSangkar, Segitiga, dan Lingkaran. Untuk tahap awal, buatlah direktori dengan nama PaketBangun (pada contoh ini, direktori ini kita letakkan di D:\TestCode\Java\PaketBangun ). Kemudian secara berturut-turut buatlah kode program berikut dan simpan dengan nama sesuai nama kelasnya pada direktori PaketBangun. Perhatikan pada awal kode kelas selalu diawali pernyataan package PaketBangun;. Hal ini menunjukkan bahwa kelas tersebut merupakan anggota dari PaketBangun.
File: BujurSangkar.java
package PaketBangun;
class BujurSangkar extends Bangun {
private double sisi;
public BujurSangkar(int s) {
sisi = s;
}
public double hitungLuas() {
double luas = sisi * sisi;
return luas;
}
}
File: Segitiga.java
package PaketBangun;
class Segitiga extends Bangun {
private double alas;
private double tinggi;
public Segitiga (int a, int t) {
alas = a;
tinggi = t;
}
public double hitungLuas() {
double luas = 0.5 * alas * tinggi;
return luas;
}
}
File: Lingkaran.java
package PaketBangun;
class Lingkaran extends Bangun {
private double jarijari;
private final double PI = 3.1416;
public Lingkaran(int r) {
jarijari = r;
}
public double hitungLuas() {
double luas = PI * jarijari * jarijari;
return luas;
}
}
Setelah itu, lakukan pengaturan classpath seperti terlihat pada sub label awal. Dan, lakukan kompilasi pada ketiga file tersebut di atas, sehingga akan diperoleh hasil file seperti gambar 8.18.
Setelah kompilasi berhasil, buatlah file baru di direktori D:\TestCode\Java, misalnya dengan nama PakaiPaketBangun.java. Kemudian ketikkan kode berikut ini pada file tersebut. Kompilasi dan jalankan kode program tersebut.
//import seluruh kelas pada PaketBangun
import PaketBangun.*;
class PakaiPaketBangun {
public static void main(String[] args) {
BujurSangkar b = new BujurSangkar(12);
Segitiga s = new Segitiga(5, 6);
Lingkaran l = new Lingkaran(4);
System.out.println("Luas bujursangkar : " +
b.hitungLuas());
System.out.println();
System.out.println("Luas segitiga : " +
s.hitungLuas());
System.out.println();
System.out.println("Luas lingkaran: " +
l.hitungLuas());
System.out.println();
}
}
Perhatikan cara penulisan untuk memanggil paket. Jika kita hanya membutuhkan kelas Lingkaran saja, maka perlu menuliskan import PaketBangun.Lingkaran;. tetapi jika kita butuh semua kelas, maka kita menuliskan dengan cara import PaketBangun.*;. Jika kita jalankan perintah ini maka hasilnya akan sama persis dengan contoh 8.33. Perbedaannya adalah pada contoh 8.32 kelas-kelas berada pada satu file, sedangkan pada contoh 8.33 kelas-kelas berada pada filenya masing-masing dan baru dikelompokkan dengan menggunakan package.
Interface atau antar muka pada bahasa pemrograman Java sangat mirip dengan kelas, tapi tanpa atribut kelas dan memiliki metode yang dideklarasikan tanpa isi. Deklarasi metode pada sebuah interface dapat diimplementasikan oleh kelas lain. Sebuah kelas dapat mengimplementasikan lebih dari satu interface. Metode pada interface yang diimplementasikan pada suatu kelas harus sama persis dengan yang ada pada interface. Interface digunakan, jika kita ingin kelas yang tidak berhubungan mengimplementasikan method yang sama. Perhatikan contoh berikut ini.
Contoh 8.34. Pembuatan interface.
interface Bentuk {
public double luas();
public double volume();
}
Pada contoh ini kita membuat sebuah interface dengan nama Bentuk yang mempunyai dua method yaitu luas() dan volume(). Perhatikan penulisan interface. Kedua method yang ada dideklarasikan tanpa isi. Kita dapat menggunakan interface ini untuk membuat kelas baru dan mengimplementasikan interface ini dalam kelas tersebut. Perhatikan contoh berikut ini.
Contoh 8.34. Penggunaan interface.
class Kubus implements Bentuk {
int x = 10;
public double luas( ) {
return (6 * x * x);
}
public double volume() {
return (x * x * x);
}
}
class Lingkaran implements Bentuk {
int radius = 10;
public double luas() {
return (Math.PI * radius * radius);
}
public double volume() {
return 0;
}
}
0 komentar :
Posting Komentar
Terima kasih, atas saran atau usulan anda.