Bab.
8 Objek dan Kelas
8.1 Introduksi
Setelah belajar sejauh ini, Anda
akan mampu menyelesaikan banyak masalah pemrograman menggunakan seleksi, loop,
metode, dan array. Namun, fitur-fitur JAVA ini tidak cukup untuk mengembangkan
antarmuka grafikal (GUI, graphical user
interface) dan rekayasa perangkat lunak berskala besar. Dimisalkan Anda
ingin mengembangkan suatu GUI seperti ditampilkan pada Gambar 8.1, bagaimanakah
Anda memprogramnya?
Gambar
8.1
Objek-objek GUI diciptakan dari kelas
Bab ini diawali dengan pengenalan
pemrograman berorientasi objek, yang akan memampukan Anda untuk mengembangkan
GUI dan rekayasa perangkat lunak berskala besar.
8.2 Mendefinisikan Kelas untuk
Objek
Pemrograman berorientasi objek
(OOP, object-oriented programming) melibatkan
pemrograman menggunakan objek. Suatu objek merepresentasikan suatu entitas
dalam dunia nyata yang bisa secara mudah diidentifikasi. Sebagai contoh,
seorang siswa, sebuah meja, suatu lingkaran, dan bahkan suatu pinjaman juga
bisa dipandang sebagai objek. Suatu objek memiliki identitas, keadaan, dan
watak yang unik.
·
Keadaan suatu objek (dikenal
juga dengan atribut) direpresentasikan oleh bidang data dengan nilai-nilai
terkini. Suatu objek Lingkaran,
misalnya, memiliki bidang data radius,
yang merupakan atribut yang mengkarakteristikkan Lingkaran. Suatu objek Persegi
memiliki bidang data lebar dan tinggi, yang mengkarakteristikkan Persegi.
·
Watak suatu objek (dikenal juga
dengan aksi) didefinisikan oleh metode. Memanggil suatu metode pada suatu objek
berarti meminta objek untuk melakukan suatu aksi. Sebagai contoh, Anda bisa
mendefinisikan suatu metode dapatLuas
untuk objek-objek Lingkaran. Suatu
objek Lingkaran dapat memanggil
metode dapatLuas untuk memberikan nilai
balik luas suatu lingkaran.
Objek-objek bertipe sama
didefinisikan di dalam kelas yang sama. Suatu kelas merupakan suatu template, blueprint, atau kontrak yang
mendefinisikan apa bidang data dan metode suatu objek. Suatu objek merupakan
suatu instans dari suatu kelas. Anda bisa menciptakan banyak instans dari suatu
kelas. Menciptakan instans disebut dengan instansiasi. Gambar 8.2 menunjukkan
suatu kelas, bernama Lingkaran, dan
tiga objeknya.
Gambar
8.2
Kelas merupakan suatu template untuk menciptakan objek-objek
Gambar
8.3
Kelas merupakan suatu konstruksi yang mendefinisikan objek-objek bertipe sama
Suatu kelas JAVA menggunakan
variabel untuk mendefinisikan bidang data dan menggunakan metode untuk
mendefinisikan aksi atau tindakan. Sebagai tambahan di dalam kelas, JAVA juga
menyediakan metode-metode spesial, dikenal dengan konstruktor, yang dipanggil
untuk menciptakan suatu objek baru. Suatu konstruktor dapat melakukan sembarang
aksi, tetapi sebenarnya didesain untuk melakukan penginisialisasian, seperti
menginisialisasi bidang data pada objek. Gambar 8.3 menunjukkan suatu contoh
mendefinisikan suatu kelas.
Kelas Lingkaran berbeda dengan semua kelas yang telah Anda jumpai pada
buku ini. Kelas Lingkaran tidak
memiliki metode main dan oleh karena itu tidak bisa dijalankan; Kelas ini
merupakan suatu definisi untuk objek-objek Lingkaran.
Ilustrasi objek dan template kelas
pada Gambar 8.2 dapat distandarisasi menggunakan notasi UML (unified modeling language). Notasi ini,
ditunjukkan pada Gambar 8.4, disebut dengan diagram
kelas UML atau diagram kelas
saja. Dalam diagram kelas, bidang data dinotasikan dengan
namaBidangData: tipeBidangData
Konstruktor dinotasikan dengan
NamaKelas(namaParameter: tipeParameter)
Metode dinotasikan dengan
namaMetode(namaParameter: tipeParameter): tipeNilaiBalik
Gambar
8.4
Kelas dan objek dapat direpresentasikan menggunakan notasi UML
8.3 Contoh: Mendefinisikan Kelas
dan Menciptakan Objek
Bagian ini akan menyajikan dua
contoh mendefinisikan kelas dan menggunakan kelas untuk menciptakan objek. Kode8.1
merupakan suatu program yang mendefinisikan kelas Lingkaran dan menggunakannya untuk menciptakan objek-objek. Untuk
menghindari konflik penamaan dengan beberapa versi terperbaiki dari kelas Lingkaran, maka pada contoh ini diberi
nama kelas Lingkaran1.
Program mengkonstruksi tiga objek
lingkaran dengan radius 1.0, 25, dan 125 dan menampilkan radius dan luas tiap
objek lingkaran.
Kode8.1 UjiLingkaran1.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
public class UjiLingkaran1 {
/** Metode utama */
public
static void main(String[] args) {
// Menciptakan suatu objek lingkaran1
dengan radius 1.0
Lingkaran1 lingkaran1 = new Lingkaran1();
System.out.println("Luas lingkaran dengan radius "
+ lingkaran1.radius + " adalah
" + lingkaran1.dapatLuas());
// Menciptakan suatu
objek lingkaran2 dengan radius 25
Lingkaran1 lingkaran2 = new
Lingkaran1(25);
System.out.println("Luas lingkaran dengan radius "
+ lingkaran2.radius + " adalah " +
lingkaran2.dapatLuas() );
// Menciptakan suatu
objek lingkaran2 dengan radius 25
Lingkaran1 lingkaran3 = new
Lingkaran1(125);
System.out.println("Luas lingkaran dengan radius "
+ lingkaran3.radius + " adalah " +
lingkaran3.dapatLuas());
// Memodifikasi
radius lingkaran
lingkaran2.radius = 100;
System.out.println("Luas lingkaran dengan radius "
+ lingkaran2.radius + " adalah " +
lingkaran2.dapatLuas());
}
}
// Mendefinisikan kelas Lingkaran1 dengan dua konstruktor
class Lingkaran1 {
double
radius;
/** Mengkonstruksi
suatu objek Lingkaran1 dengan radius 1 */
Lingkaran1(){
radius = 1.0;
}
/** Mengkonstruksi
suatu objek Lingkaran1 dengan radius tertentu */
Lingkaran1(double radiusBaru){
radius
= radiusBaru;
}
/** Mengembalikan luas lingkaran */
double dapatLuas(){
return
radius * radius * Math.PI;
}
}
|
Keluaran
Luas lingkaran dengan radius 1.0 adalah 3.141592653589793
Luas lingkaran dengan radius 25.0 adalah 1963.4954084936207
Luas lingkaran dengan radius 125.0 adalah 49087.385212340516
Luas lingkaran dengan radius 100.0 adalah 31415.926535897932
Program memuat dua kelas. Yang
pertama, UjiLingkaran1, adalah kelas
utama. Satu-satunya tujuan kelas ini adalah untuk menguji kelas kedua, Lingkaran1. Ketika Anda menjalankan
program ini, sistem runtime JAVA akan
memanggil metode main dalam kelas
utama.
Anda bisa menempatkan dua kelas di
dalam satu file, tetapi hanya boleh satu kelas yang publik. Seperti yang Anda
telah ketahui bahwa nama kelas publik harus sama dengan nama file. Oleh karena
itu, nama file adalah UjiLingkaran1.java,
karena UjiLingkaran1 merupakan kelas
publik.
Kelas utama memuat metode main (baris 3) yang menciptakan tiga
objek. Sama seperti menciptakan suatu array, operator new digunakan untuk menciptakan suatu objek dari konstruktor. new Lingkaran1() menciptakan suatu
objek dengan radius 1.0 (baris 5), new
Lingkaran1(25) menciptakan suatu
objek dengan radius 25 (baris 10), dan new
Lingkaran1(125) menciptakan suatu objek dengan radius 125 (baris 15).
Ketiga objek (yang direferensikan
oleh lingkaran1, lingkaran2, dan lingkaran3) memiliki data yang berbeda tetapi metode yang sama.
Oleh karena itu, Anda bisa menghitung masing-masing luas lingkaran menggunakan
metode dapatLuas(). Bidang-bidang
data dapat diakses lewat referensi objek lingkaran1.radius,
lingkaran2.radius, dan lingkaran3.radius. Objek dapat
memanggil metodenya lewat referensi objek menggunakan lingkaran1.dapatLuas(), lingkaran1.dapatLuas(),
dan lingkaran1.dapatLuas().
Ketiga objek independen satu sama
lain. Radius lingkaran1 diubah
menjadi 100 pada baris 100. Radius baru objek tersebut dan luas lingkaran
ditampilkan pada baris 21-22.
Ada banyak cara dalam menulis
program JAVA. Sebagai contoh, Anda bisa mengkombinasikan dua kelas menjadi
satu, seperti yang ditunjukkan pada kode8.2.
Kode8.2 Lingkaran1.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
public class UjiLingkaran1 {
/** Metode utama */
public
static void main(String[] args) {
// Menciptakan suatu objek lingkaran1
dengan radius 1.0
Lingkaran1 lingkaran1 = new Lingkaran1();
System.out.println("Luas lingkaran dengan radius "
+ lingkaran1.radius + " adalah
" + lingkaran1.dapatLuas());
// Menciptakan suatu
objek lingkaran2 dengan radius 25
Lingkaran1 lingkaran2 = new
Lingkaran1(25);
System.out.println("Luas lingkaran dengan radius "
+ lingkaran2.radius + " adalah " +
lingkaran2.dapatLuas() );
// Menciptakan suatu
objek lingkaran2 dengan radius 25
Lingkaran1 lingkaran3 = new
Lingkaran1(125);
System.out.println("Luas lingkaran dengan radius "
+ lingkaran3.radius + " adalah " +
lingkaran3.dapatLuas());
// Memodifikasi
radius lingkaran
lingkaran2.radius = 100;
System.out.println("Luas lingkaran dengan radius "
+ lingkaran2.radius + " adalah " +
lingkaran2.dapatLuas());
}
double
radius;
/** Mengkonstruksi
suatu objek Lingkaran1 dengan radius 1 */
Lingkaran1(){
radius = 1.0;
}
/** Mengkonstruksi
suatu objek Lingkaran1 dengan radius tertentu */
Lingkaran1(double radiusBaru){
radius
= radiusBaru;
}
/** Mengembalikan luas lingkaran */
double dapatLuas(){
return
radius * radius * Math.PI;
}
}
|
Sebagai tambahan pengalaman Anda,
di sini disajikan suatu contoh lain, kelas TV.
Setiap TV merupakan suatu objek dengan keadaan-keadaan (kanal sekarang, level
volume sekarang, hidup, atau mati), dan watak-watak (ubah kanal, ubah volume,
dan matikan/hidupkan). Anda bisa menggunakan suatu kelas untuk memodelkan TV.
Diagram UML untuk kelas TV ditampilkan pada Gambar 8.5. Kode8.3 disajikan untuk
memberikan program yang mendefinisikan kelas TV.
Gambar
8.5
Diagram kelas TV
Kode8.3 TV.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public class TV {
int kanal = 1; // kanal
default 1
int levelVolume = 1; // level
volume default 1
boolean hidup = false; // TV secara default mati
public TV() {
}
public void hidupKan() {
hidup = true;
}
public void matiKan() {
hidup = false;
}
public void setKanal(int kanalBaru) {
if (hidup && kanalBaru >= 1 && kanalBaru <=
120)
kanal = kanalBaru;
}
public void setVolume(int levelVolumeBaru)
{
if (hidup && levelVolumeBaru >= 1 &&
levelVolumeBaru <= 7)
levelVolume =
levelVolumeBaru;
}
public void kanalNaik() {
if (hidup && kanal < 120)
kanal++;
}
public void kanalTurun() {
if (hidup && kanal > 1)
kanal--;
}
public void volumeNaik() {
if (hidup && levelVolume < 7)
levelVolume++;
}
public void volumeTurun() {
if (hidup && levelVolume > 1)
levelVolume--;
}
}
|
Perhatikan bahwa kanal dan level
volume tidak berubah bila TV tidak hidup. Sebelum kanal dan level volume
diubah, nilai sekarang dari keduanya diperiksa dulu untuk memastikan bahwa
keduanya berada di dalam rentang yang diijinkan. Kode8.4 memberikan suatu program
yang menggunakan kelas TV untuk
menciptakan dua objek.
Kode8.4 UjiTV.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class UjiTV {
public
static void main(String[] args) {
TV tv1 = new TV();
tv1.hidupKan();
tv1.setKanal(30);
tv1.setVolume(3);
TV tv2 = new TV();
tv2.hidupKan();
tv2.kanalNaik();
tv2.kanalTurun();
tv2.volumeNaik();
System.out.println("kanal tv1 adalah " + tv1.kanal
+ " dan level volumenya adalah "+ tv1.levelVolume);
System.out.println("kanal tv1 adalah " + tv2.kanal
+ " dan level volumenya adalah " + tv2.levelVolume);
}
}
|
Program menciptakan dua objek pada
baris 3 dan baris 8 dan memanggil metode-metode pada kedua objek tersebut untuk
melakukan beberapa aksi untuk menetapkan kanal, level volume, menaikkan kanal
dan level volume. Program menampilkan keadaan-keadaan objek pada baris 14-17. Metode-metode
dipanggil menggunakan sintaks seperti tv1.hidupKan
(baris 4). Bidang-bidang data diakses menggunakan sintaks seperti tv1.kanal (baris14).
Kedua contoh sebelumnya memberikan
kepada Anda sedikit pengetahuan dan pengalaman tentang kelas dan objek. Anda
tentu masih mempunyai banyak pertanyaan terkait dengan konstruktor, objek,
variabel referensi, pengaksesan bidang data, dan pemanggilan metode. Hal-hal
ini akan terjawab pada bagian-bagian selanjutnya.
8.4 Menciptakan Objek Menggunakan
Konstruktor
Konstruktor merupakan bentuk
spesial dari suatu objek, dengan tiga kekhususan sebagai berikut:
·
Suatu konstruktor harus
memiliki nama sama dengan nama kelas.
·
Konstruktor tidak boleh
memiliki nilai balik, bahkan void
sekalipun.
·
Konstruktor dipanggil
menggunakan operator new ketika
suatu objek diciptakan. Konstruktor berperan untuk menginisialisasi objek.
Sama seperti metode, konstruktor
dapat dioverload (beberapa konstruktor dapat mempunyai nama sama namun dengan
sidik yang berbeda), sehingga memudahkan untuk menciptakan objek-objek dengan
nilai-nilai inisial yang berbeda.
Adalah kesalahan yang umum terjadi
untuk menempatkan katakunci void di depan suatu konstruktor. Sebagai contoh,
public
void Lingkaran() {
}
Pada kasus ini Lingkaran() adalah suatu metode, bukan
konstruktor.
Konstruktor digunakan untuk
menciptakan objek. Untuk menciptakan suatu objek dari suatu kelas, konstruktor
dipanggil menggunakan operator new,
sebagai berikut:
new NamaKelas(argumen-argumen);
Sebagai contoh, new Lingkaran() menciptakan suatu objek
dari kelas Lingkaran menggunakan
konstruktor pertama yang didefinisikan di dalam kelas Lingkaran, dan new
Lingkaran(25) menciptakan suatu objek dari kelas Lingkaran menggunakan konstruktor kedua yang didefinisikan di dalam
kelas Lingkaran.
Suatu kelas biasanya menyediakan
suatu konstruktor tanpa argumen (misalnya, Lingkaran()).
Konstruktor semacam itu dikenal dengan konstruktor-tanpa-argumen.
Suatu kelas dapat pula didefinisikan
tanpa konstruktor. Pada kasus ini, konstruktor-tanpa-argumen diciptakan secara
implisit di dalam kelas oleh JAVA.
8.5 Mengakses Objek Lewat Variabel
Referensi
Objek yang baru saja diciptakan
dialokasikan di dalam memori. Objek tersebut dapat diakses lewat variabel
referensi.
8.5.1 Variabel Referensi dan Tipe
Referensi
Objek dapat diakses lewat variabel
referensi, yang memuat referensi kepada objek. Variabel tersebut dideklarasikan
menggunakan sintaks sebagai berikut:
NamaKelas varRefObjek;
Suatu kelas sebenarnya tipe yang
didefinisikan programmer. Jadi, kelas adalah suatu tipe, yang berarti bahwa
suatu variabel tipe kelas dapat mereferensi atau menunjuk suatu instans dari
kelas. Statemen berikut ini mendeklarasikan variabel lingkaranKu menjadi bertipe Lingkaran.
Lingkaran lingkaranKu;
Variabel lingkaranKu dapat mereferensi suatu objek Lingkaran. Statemen selanjutnya menciptakan suatu objek dan
menugaskan referensinya kepada lingkaranKu:
lingkaranKu = new Lingkaran();
Menggunakan sintaks di bawah ini,
Anda bisa menggabungkan dalam satu statemen pendeklarasian suatu variabel
referensi objek, penciptaan suatu objek, dan penugasan suatu referensi objek
kepada variabel:
NamaKelas varRefObjek = new NamaKelas();
Berikut adalah suatu contoh:
Lingkaran lingkaranKu = new Lingkaran();
Variabel lingkaranKu memuat suatu referensi kepada suatu objek Lingkaran.
|
Suatu variabel referensi objek sebenarnya merupakan
suatu referensi kepada objek yang ditunjuk. Jadi, dengan kata lain, suatu
variabel referensi objek dan suatu objek adalah berbeda, tetapi dalam banyak
kasus perbedaan ini bisa diabaikan. Jadi, demi kesederhanaan, dapat
diperbolehkan untuk mengatakan bahwa lingkaranKu merupakan suatu objek Lingkaran,
karena bila mengatakan lingkaranKu adalah suatu variabel yang memuat suatu referensi
yang menunjuk ke suatu objek Lingkaran merupakan hal yang cukup melelahkan.
Perhatikan bahwa array diperlakukan sebagai objek
dalam JAVA. Array diciptakan menggunakan operator new. Suatu
variabel array sebenarnya memuat suatu referensi yang menunjuk ke suatu
array.
|
8.5.2 Mengakses Bidang Data dan
Metode Suatu Objek
Setelah suatu objek diciptakan,
datanya dapat diakses dan metodenya dapat dipanggil melalui operator dot (.),
yang juga dikenal dengan operator akses
anggota objek:
·
varRefObjek.bidangData
mereferensi atau menunjuk suatu bidang data di dalam suatu objek.
·
varRefObjek.namaMetode(argumen) memanggil
suatu metode pada suatu objek.
Sebagai
contoh, lingkaranKu.radius
mereferensi data radius dalam lingkaranKu, dan lingkaranKu.dapatLuas() memanggil metode dapatLuas() pada lingkaranKu.
Bidang data radius disebut dengan variabel instans, karena independen pada
instans tertentu. Dengan alasan yang sama, metode dapatLuas() disebut dengan metode instans, karena Anda hanya dapat
memanggilnya hanya pada instans tertentu saja.
|
Ingat bahwa Anda pernah menggunakan Math.namaMetode(argumen) (misalnya, Math.pow(3,2.1)) untuk memanggil suatu metode dalam kelas Math. Dapatkah
Anda memanggil dapatLuas() menggunakan Lingkaran.dapatLuas()? Jawabannya adalah tidak, karena semua metode di
dalam kelas Math merupakan metode statik, yang didefinisikan
menggunakan katakunci static. Akan tetapi, dapatLuas() merupakan suatu metode instans, jadi nonstatik dan
harus dipanggil dari suatu objek menggunakan sintaks varRefObjek.namaMetode(argumen) (misalnya, lingkaranKu.dapatLuas()). Penjelasan berikutnya diberikan pada bagian 8.7.
Kadang-kala Anda bisa menciptakan suatu objek tanpa
perlu secara eksplisit menugaskannya kepada suatu variabel referensi, seperti
contoh ini:
new
Lingkaran();
atau
System.out.println("Luas adalah " + new Lingkaran(5).dapatLuas());
|
8.5.3 Mereferensi Bidang Data dan
Nilai null
Bidang data dapat berupa tipe
referensi. Sebagai contoh, kelas Mahasiswa
berikut ini memuatu suatu bidang data nama
yang bertipe String (tipe
referensi). String merupakan suatu
tipe referensi yang didefinisikan di dalam kelas JAVA.
class
Mahasiswa {
String nama; // nama memiliki nilai default
null
int umur; // umur memiliki nilai default 0
boolean apaJurusan; // apaJurusan memiliki nilai
default false
char jenisKelamin; // jenisKelamin memiliki nilai default
'\u0000'
}
Jika suatu bidang data bertipe
referensi yang tidak menunjuk sembarang objek, maka JAVA menginisialisasinya
dengan nilai null. Nilai null merupakan suatu literal sama
seperti true atau false. Jika true dan false merupakan
literal untuk tipe boolean, maka null adalah literal untuk tipe
referensi.
Nilai default null diberikan suatu bidang data bertipe referensi, 0 untuk bertipe
numerik, false untuk bertipe boolean, dan ‘\0000’ untuk bertipe char.
Akan tetapi, JAVA tidak menugaskan nilai default bagi variabel lokal. Kode
berikut ini menampilkan nilai-nilai default bagi bidang-bidang data nama, usia, apaJurusan, dan jenisKelamin pada objek Mahasiswa:
class
Uji {
public static void main(String[] args) {
Mahasiswa mahasiswa = new Mahasiswa();
System.out.println("nama? "+
mahasiswa.nama);
System.out.println("usia? "+
mahasiswa.usia);
System.out.println("apaJurusan?
"+ mahasiswa.apaJurusan);
System.out.println("jenis kelamin?
"+ mahasiswa.jenisKelamin);
}
}
Kode berikut ini akan menghasilkan
error kompilasi, karena variabel-variabel lokal tidak diinisialisasi:
class
Test {
public static void main(String[]
args) {
int x; // x tidak memiliki nilai
default
String y; // y tidak memiliki nilai
default
System.out.println("x = " +
x);
System.out.println("y = " +
y);
}
}
8.5.4 Perbedaan Antara Variabel
Tipe Primitif dan Tipe Referensi
Setiap variabel merepresentasikan
suatu lokasi memori yang menampung suatu nilai. Ketika Anda mendeklarasikan
suatu variabel, Anda memberitahukan kepada kompiler tipe nilai yang dapat
dimuat oleh suatu variabel. Untuk variabel tipe primitif, nilainya adalah tipe
primitif. Untuk variabel tipe referensi, nilainya adalah suatu referensi yang
mengindikasikan alamat suatu objek. Sebagai contoh, seperti yang ditunjukkan
pada Gambar 8.6, nilai variabel int,
i, adalah nilai int, 1, dan nilai objek Lingkaran,
c, memuat suatu referensi yang
menunjuk dimana isi objek Lingkaran
disimpan di dalam memori.
Gambar
8.6
Suatu variabel tipe primitif memuat suatu nilai tipe primitif, dan suatu
variabel tipe referensi memuat suatu referensi yang menunjuk dimana suatu objek
disimpan dalam memori
Ketika Anda menugaskan suatu
variabel kepada variabel lain, variabel yang lain itu memiliki nilai yang sama
dengan variabel pertama. Untuk variabel tipe primitif, nilai riil suatu
variabel ditugaskan kepada variabel lain. Untuk tipe referensi, referensi suatu
variabel ditugaskan kepada variabel lain. Seperti ditampilkan pada Gambar 8.7, statemen
penugasan i = j menyalin konten j kepada i untuk variabel tipe primitif. Seperti ditampilkan pada Gambar
8.8, statemen penugasan c1 = c2 menyalin
referensi c2 kepada c1 untuk variabel tipe primitif.
Setelah penugasan, variabel c1 dan c2 menunjuk kepada objek yang sama.
Gambar
8.7
Variabel primitif j disalin kepada
variabel i
Gambar
8.8
Variabel referensi c2 disalin kepada
variabel c1
|
Seprti ditunjukkan pada Gambar 8.8, setelah statemen
penugasan c1 = c2, c1 menunjuk ke objek yang sama dengan yang ditunjuk
oleh c1. Objek yang sebelumnya direferensi oleh c1 tidak
lagi berguna dan sekarang menjadi sampah. Sampah seperti ini menempati
memori. Sistem runtime JAVA secara otomatis membersihkan sampah ini dan
mengosongkan memori tersebut. Proses ini disebut juga dengan pemungutan
sampah atau garbage
collection.
Jika Anda mengetahui bahwa suatu objek tidak lagi
dibutuhkan, Anda bisa secara eksplisit menugaskan nilai null kepada
suatu variabel referensi yang menunjuk objek itu. JVM secara otomatis akan
mengosongkan memori jika suatu objek tidak direferensi oleh sembarang
variabel referensi.
|
8.6 Menggunakan Kelas dari Pustaka
JAVA
Kode8.1 mendefinisikan kelas Lingkaran1 dan menciptakan beberapa
objek dari kelas tersebut. Anda juga bisa menggunakan kelas dari pustaka JAVA
untuk mengembangkan program Anda. Bagian ini memberikan beberapa contoh kelas
di dalam pustaka JAVA.
8.6.1 Kelas Date
Pada kode2.8, TampilWaktuSekarang.java,
Anda telah belajar bagaimana mendapatkan waktu saat ini menggunakan System.currentTimeMillis(). Anda
menggunakan operator pembagian dan modulus untuk mendapatkan detik, menit, dan
jam saat ini. JAVA menyediakan suatu enkapsulasi bebas-sistem untuk tanggal dan
waktu dalam kelas java.util.Date,
seperti yang ditampilkan pada Gambar 8.9.
Gambar
8.9
Suatu objek Date merepresentasikan tanggal dan waktu spesifik
Anda bisa menggunakan konstruktor
tanpa-argumen dalam kelas Date untuk
menciptakan suatu instans untuk waktu dan tanggal sekarang, metode getTime() untuk jumlah waktu dalam mili
detik sejak 1 Januari 1970, dan metode toString()
untuk memberikan tanggal dan waktu dalam string. Sebagai contoh, kode berikut
ini
java.util.Date tanggal = new java.util.Date();
System.out.println("Jumlah waktu
sejak 1 Januari 1970 adalah " +
tanggal.getTime()
+ " milidetik");
System.out.println(tanggal.toString());
menampilkan keluaran:
Jumlah waktu sejak 1 Januari 1970 adalah 1100647310284
milidetik
Mon Nov 5
14:33:30 EST 2012
kelas Date memiliki konstruktor lain, Date(long elapseTime), yang dapat digunakan untuk mengkonstruksi
suatu objek Date pada waktu yang
diberikan, terhitung sejak 1 Januari 1970.
8.6.2 Kelas Random
Anda telah menggunakan Math.random() untuk mendapatkan suatu
nilai acak bertipe double dengan
rentang 0.0 sampai 1.0. Cara lain dalam membangkitkan angka acak adalah dengan
menggunakan kelas java.util.Random,
seperti yang ditampilkan pada Gambar 8.10, yang dapat membangkitkan suatu nilai
acak int, long, double, float, dan boolean.
Gambar
8.10
Suatu objek Random dapat digunakan untuk membangkitkan nilai-nilai acak
Ketika Anda menciptakan suatu
objek Random, Anda harus menentukan
seed atau menggunakan seed default. Konstruktor tanpa-argmen menciptakan suatu
objek Random menggunakan selisih
waktu sekarang sebagai seed. Jika dua objek Random memiliki seed yang sama, maka akan dihasilkan nilai acak
yang sama. Sebagai contoh, kode berikut ini menciptakan dua objek Random dengan seed yang sama, 3:
Random
acak1 = new Random(3);
System.out.print("Dari
acak1: ");
for
(int i
= 0; i < 10; i++)
System.out.print(acak1.nextInt(1000) +
" ");
Random
acak2 = new Random(3);
System.out.print("\nDari
acak2: ");
for
(int i
= 0; i < 10; i++)
System.out.print(acak2.nextInt(1000) +
" ");
Kode tersebut menghasilkan runtun
nilai acak int yang sama:
Dari
acak1: 734 660 210 581 128 202 549 564 459 961
Dari acak2:
734 660 210 581 128 202 549 564 459 961
8.6.3 Menampilkan Komponen GUI
Ketika Anda mengembangkan program
untuk menciptakan antarmuka grafikal (GUI), Anda akan menggunakan kelas-kelas
JAVA seperti JFrame, JButton, JradioButton, JComboBox,
dan JList. Kode8.5 merupakan suatu
contoh dua jendela menggunakan kelas JFrame.
Keluaran program ditampilkan pada 8.11.
Gambar
8.11
Program menciptakan dua jendela menggunakan kelas JFrame
Kode8.5 UjiFrame.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import javax.swing.JFrame;
public class UjiFrame {
public
static void main(String[] args) {
JFrame frame1 = new JFrame();
frame1.setTitle("Jendela 1");
frame1.setSize(200, 150);
frame1.setLocation(200, 100);
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame1.setVisible(true);
JFrame frame2 = new JFrame();
frame2.setTitle("Jendela 2");
frame2.setSize(200, 150);
frame2.setLocation(410, 100);
frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame2.setVisible(true);
}
}
|
Program ini menciptakan dua objek
kelas JFrame (baris 5 dan 12) dan
kemudian menggunakan metode-metode setTitle,
setSize, setLocation, setDefaultCloseOperation,
dan setVisible untuk menetapkan
watak-watak objek. Metode setTitle
menetapkan suatu judul pada jendela (baris 6 dan 13). Metode setSize menetapkan lebar dan tinggi
jendela (baris 7 dan 14). Metode setLocation
menetapkan lokasi pojok kiri-atas jendela (baris 8 dan 15). Metode setDefaultCloseOperation menghentikan program
ketika frame ditutup (baris 9 dan 16). Metode setVisible untuk menampilkan jendela.
Anda bisa menambahkan
komponen-komponen GUI, seperti tombol, label, bidang teks, kotak periksa, dan
kotak combo dalam jendela.
Kode8.6 KomponenGUI.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
import javax.swing.*;
public class KomponenGUI {
public
static void main(String[] args) {
// Menciptakan suatu tombol dengan teks YA
JButton jbtYA = new JButton("YA");
// Menciptakan suatu tombol dengan teks
Batal
JButton jbtBatal = new JButton("Batal");
// Meciptakan suatu label dengan teks
"Masukkan nama Anda: "
JLabel jlblNama = new JLabel("Masukkan nama Anda: ");
// Menciptakan suatu bidang teks dengan
teks "Ketik nama di sini"
JTextField jtfNama = new JTextField("Ketik nama di sini");
// Menciptakan suatu kotak periksa dengan
teks Tebal
JCheckBox jchkTebal = new JCheckBox("Tebal");
// Menciptakan suatu
kotak periksa dengan teks Miring
JCheckBox jchkMiring = new
JCheckBox("Miring");
// Menciptakan suatu kotak radio dengan
teks Merah
JRadioButton jrbMerah = new
JRadioButton("Merah");
// Menciptakan suatu kotak radio dengan
teks Kuning
JRadioButton jrbKuning = new
JRadioButton("Kuning");
// Menciptakan suatu kotak combo dengan
beberapa pilihan
JComboBox jcboWarna = new JComboBox(new
String[]{"Sangat Pintar",
"Pintar", "Cukup",
"Kurang"});
// Menciptakan suatu panel pada
komponen-komponen
JPanel panel = new JPanel();
panel.add(jbtYA); // Menambah tomobol YA
pada panel
panel.add(jbtBatal); // Menambah tombol
Batal pada panel
panel.add(jlblNama); // Menambah label
pada label
panel.add(jtfNama); // Menambah bidang
teks pada panel
panel.add(jchkTebal); // Menambah kotak
periksa pada panel
panel.add(jchkMiring); // Menambah kotak
periksa pada panel
panel.add(jrbMerah); // Menambah kotak
radio pada panel
panel.add(jrbKuning); // Menambah kotak
radio pada panel
panel.add(jcboWarna); // Menambah kotak
combo pada panel
JFrame frame = new JFrame(); //
Menciptakan suatu frame
frame.add(panel); // Menambah panel pada
frame
frame.setTitle("Tampilkan Komponen GUI");
frame.setSize(450, 100);
frame.setLocation(200, 100);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
|
Keluarannya adalah
yang sama dengan apa yang
ditampilkan pada Gambar 8.1.
8.7 Variabel, Konstanta, dan
Metode Statik
Bidang data radius dalam kelas Lingkaran
pada kode8.1 dikenal sebagai variabel
instans. Suatu variabel instans terikat dengan instans kelas tertentu;
variabel ini tidak dipakai bersama oleh objek-objek kelas yang sama. Sebagai
contoh, dimisalkan bahwa Anda menciptakan objek-objek berikut ini:
Lingkaran
lingkaran1 = new Lingkaran();
Lingkaran
lingkaran2 = new Lingkaran (5);
radius dalam lingkaran1
independen terhadap radius dalam lingkaran2 dan disimpan pada lokasi
yang berbeda. Perubahan yang dilakukan terhadap radius dalam lingkaran1
tidak berpengaruh terhadap radius
dalam lingkaran2.
Jika Anda menginginkan semua
instans suatu kelas menggunakan bersama bidang data, maka Anda bisa menggunakan
variabel statik, yang juga dikenal
dengan variabel kelas. Variabel
statik menyimpan nilai di dalam lokasi memori yang digunakan bersama. Karena
lokasi digunakan bersama, jika suatu objek mengubah nilai suatu variabel
statik, maka semua objek dalam kelas yang sama akan terpengaruh. JAVA juga
mendukung keberadaan metode statik, seperti variabel statik. Metode statik
dipangil tanpa harus menciptakan suatu instans dari kelas.
Gambar
8.12
Variabel instans independen satu sama lain, dan variabel/metode statik dipakai
bersama
Kelas Lingkaran dapat dimodifikasi dengan menambahkan suatu variabel
statik jumlahObjek untuk menghitung
jumlah objek yang diciptakan. Ketika objek pertama dari kelas ini diciptakan, jumlahObjek menjadi 1. Ketika objek
kedua dari kelas ini diciptakan, jumlahObjek
menjadi 2. Diagram kelas UML atas kelas Lingkaran
ditampilkan pada Gambar 8.12. Kelas Lingkaran
mendefinisikan variabel instans radius
dan variabel statik jumlahObjek,
metode-metode instans dapatRadius, tetapkanRadius, dan dapatLuas, dan metode statik dapatJumlahObjek.
Untuk mendeklarasikan suatu
variabel statik atau mendefinisikan suatu metode statik, Anda perlu menempatkan
pemodifikasi static dalam deklarasi
variabel atau metode.
static
int jumlahObjek;
static
int dapatJumlahObjek()
{
return jumlahObjek;
}
Konstanta di dalam kelas dipakai
secara bersama oleh semua objek pada kelas yang sama. Jadi, konstanta harus
dideklarasikan final static. Sebagai
contoh, konstanta PI dalam kelas Math didefinisikan sebagai:
final static
double PI = 3.14159265358979323846;
Kelas lingkaran yang baru, Kelas2, dideklarasikan pada kode8.7:
Kode8.7 Lingkaran2.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public class Lingkaran2 {
/** Radius lingkaran */
double
radius;
/** Jumlah objek yang diciptakan */
static int jumlahObjek = 0;
/** Mencipatakan suatu objek Lingkaran
dengan radius 1 */
Lingkaran2() {
radius = 1.0;
jumlahObjek++;
}
/** Mencipatakan suatu
objek Lingkaran dengan radius ditentukan */
Lingkaran2(double radiusBaru) {
radius = radiusBaru;
jumlahObjek++;
}
/** Memberikan nilai balik jumlahObjek */
static int dapatJumlahObjek() {
return
jumlahObjek;
}
/** Memberikan nilai balik luas lingkaran */
double
dapatLuas() {
return
radius * radius * Math.PI;
}
}
|
Metode dapatJumlahObjek pada kelas Lingkaran2
merupakan suatu metode statik. Contoh lain metode statik adalah showMessageDialog dan showInputDialog dalam kelas JOptionPane dan semua metode dalam
kelas Math. Metode main juga merupakan metode statik.
Metode-metode instans (misalnya, dapatLuas()) dan data instans
(misalnya, radius) hanya dapat
digunakan setelah instans diciptakan. Baik metode instans maupun data instans
dapat diakses melalui variabel referensi. Metode statik (misalnya, dapatJumlahObjek()) dan data statik
(misalnya, jumlahObjek) dapat
diakses dari instans maunpun dari nama kelasnya.
Program pada kode8.8
mendemonstrasikan bagaimana menggunakan variabel/metode instans/statik dan
mengilustrasikan pengaruh penggunaannya.
Kode8.8 UjiLingkaran2.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
public class UjiLingkaran2 {
/** Metode Utama */
public
static void main(String[] args) {
System.out.println("Sebelum menciptakan objek-objek");
System.out.println("Jumlah objek Lingkaran adalah "
+
Lingkaran2.jumlahObjek);
// Menciptakan c1
Lingkaran2 c1 = new Lingkaran2();
// Menampilkan c1 dan SEBELUM c2
diciptakan
System.out.println("\nSetelah menciptakan c1");
System.out.println("c1: radius (" + c1.radius +
") dan jumlah objek Lingkaran (" +
c1.jumlahObjek + ")");
// Menciptakan c2
Lingkaran2 c2 = new Lingkaran2(5);
// Memodifikasi c1
c1.radius = 9;
// Menampilkan c1 dan c2 SETELAH c2
diciptakan
System.out.println("\nSetelah menciptakan c2 dan memodifikasi
c1");
System.out.println("c1: radius (" + c1.radius +
") dan jumlah objek Lingkaran (" +
c1.jumlahObjek + ")");
System.out.println("c2: radius (" + c2.radius +
") dan jumlah objek Lingkaran (" +
c2.jumlahObjek + ")");
}
}
|
Keluaran
Sebelum menciptakan objek-objek
Jumlah objek Lingkaran adalah 0
Setelah menciptakan c1
c1: radius (1.0) dan jumlah objek Lingkaran (1)
Setelah menciptakan c2 dan memodifikasi c1
c1: radius (9.0) dan jumlah objek Lingkaran (2)
c2: radius (5.0) dan jumlah objek Lingkaran (2)
Ketika Anda mengkompilasi UjiLingkaran2.java, kompiler JAVA
secara otomatis mengkompile Lingkaran2.java
jika belum dikompilasi.
Variabel dan metode statik dapat
diakses tanpa perlu menciptakan objek terlebih dahulu. Baris 6 menampilkan jumlah
objek, yang bernilai 0, karena belum ada objek yang diciptakan.
Metode main menciptakan dua objek,
c1 dan c2 (baris 9 dan 18). Variabel instans radius dalam c1
dimodifikasi sehingga bernilai 9 (baris 21). Perubahan ini tidak mempengaruhi
variabel instans radius dalam c2, karena kedua variabel instans
independen satu sama lain. Variabel statik jumlahObjek
menjadi 1 setelah c1 diciptakan
(baris 9), dan menjadi 2 setelah c2
diciptakan (baris 18).
Perhatikan bahwa PI merupakan suatu konstanta yang
didefinisikan dalam kelas Math, dan Math.PI mereferensi konstanta. c1.jumlahObjek dapat pula digantikan
dengan Lingkaran2.jumlahObjek. Hal
ini akan mempermudah pembacaan program, karena pembaca akan mengerti bahwa jumlahObjek adalah variabel statik.
Variabel dan metode statik dapat
digunakan dari metode instans atau statik di dalam kelas. Akan tetapi, variabel
dan metode instans hanya bisa digunakan dari metode instans, bukan dari metode
statik, karena variabel dan metode statik tidak milik objek tertentu. Jadi,
kode berikut ini adalah salah.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
class Siantar
{
int
i = 5;
static
int k = 2;
public
static void main(String[] args) {
int
j = i; // Salah karena i adalah suatu variabel instans
m1(); // Salah karena m1() adalah
suatu metode instans
}
public
void m1() {
// Benar
karena variabel dan metode instans dan statik
// dapat
digunakan dalam suatu metode instans
i =
i + k + m2(i, k);
}
public
static int m2(int i, int j) {
return
(int)(Math.pow(i, j));
}
}
|
Perhatikan bila Anda mengganti
kode pada baris 5-8, maka program menjadi benar, karena bidang data instans i dan metode instans m1() dapat diakses dari suatu objek siantar (baris 6-7):
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
class Siantar
{
int
i = 5;
static
int k = 2;
public
static void main(String[] args) {
Siantar siantar = new Siantar();
int j = siantar.i; //
OK, siantar.i mengakses variabel instans objek
siantar.m1(); // OK karena siantar.m1() memanggil metode instans objek
}
public
void m1() {
// Benar
karena variabel dan metode instans dan statik
// dapat
digunakan dalam suatu metode instans
i =
i + k + m2(i, k);
}
public
static int m2(int i, int j) {
return
(int)(Math.pow(i, j));
}
}
|
8.8 Pemodifikasi Visibilitas
Anda bisa menggunakan pemodifikasi
visibilitas public untuk kelas,
metode, dan bidang data untuk menandakan bahwa mereka bisa diakses dari kelas
manapun. Jika pemodifikasi visibilitas tidak digunakan, maka secara default
kelas, metode, dan bidang data dapat diakses oleh sembarang kelas dalam package yang sama. Hal ini dikenal
dengan akses-paket.
Selain pemodifikasi public, JAVA juga menyediakan
pemodifikasi private dan protected untuk anggota-anggota kelas.
Bagian ini akan mengenalkan pemodifikasi private,
sedangkan pemodifikasi protected akan dikenalkan pada Bab. 11.
Pemodifikasi private membuat metoda dan bidang data hanya bisa diakses dari
dalam kelas sendiri. Gambar 8.13
mengilustrasikan bagaimana metode public
dan bidang data public dalam kelas C1 dapat diakses dari suatu kelas C2 di dalam paket yang sama dan dari
kelas C3 dalam paket yang berbeda.
Gambar
8.13
Pemodifikasi private membatasi akses
dari kelas lain, pemodifikasi default membatasi akses dari paket lain, dan
pemodifikasi public tidak membatas
akses bagi siapapun
Jika suatu kelas tidak
didefinisikan public, maka artinya hanya bisa diakses dari dalam paket yang
sama. Seperti ditunjukkan pada Gambar 8.14, C1 dapat diakses dari C2,
bukan dari C3.
Gambar
8.14
Suatu kelas nonpublik memiliki akses-paket
Suatu pemodifikasi visibilitas
menentukan bagaimana bidang data dan metode dalam suatu kelas dapat diakses
dari dua kelas. Tidak ada batasan akses terhadap bidang data dan metode dari
dalam kelas sendiri. Seperti ditampilkan pada Gambar 8.15b, suatu objek foo dari kelas Foo tidak dapat mengakses anggota privat, karena foo berada dalam kelas Test. Seperti ditunjukkan pada Gambar
8.15a, suatu objek foo dari kelas Foo dapat mengakses anggota privat,
karena foo didefinisikan di dalam
kelasnya sendiri.
Gambar 8.15 Suatu objek dapat mengakses
anggota-anggota privat jika didefinisikan di dalam kelas sendiri.
8.9 Enkapsulasi Bidang Data
Bidang data radius dan jumlahObjek
dalam kelas Lingkaran2 pada kode8.7 dapat dimodifikasi secara langsung
(misalnya, lingkaranKu.radius = 5
atau Lingkaran2.jumlahObjek = 10).
Hal ini merupakan tindakan pemrograman yang tidak baik, karena dua alasan:
·
Pertama, data bisa berubah.
Sebagai contoh, jumlahObjek
dimaksudkan untuk menghitung jumlah objek yang diciptakan, tetapi bisa saja jumlahObjek diubah secara tidak sengaja
(misalnya, Lingkaran2.jumlahObjek = 10).
·
Kedua, kelas menjadi susah
dipelihara. Seandainya Anda ingin memodifikasi kelas Lingkaran2 untuk memastikan bahwa radius harus nonnegatif setelah beberapa program menggunakannya.
Anda harus mengubah bukan saja kelas Lingkaran2 tetapi juga program-program
yang menggunakannya, karena bisa saja klien mengubah radius secara langsung
(misalnya, lingkaranKu.radius = - 5).
Untuk
mencegah pemodifikasian atas bidang data, Anda harus mendeklarasikan bidang
data privat, menggunakan pemodifikasi private.
Hal ini dikenal dengan enkapsulasi bidang
data.
Suatu bidang data privat tidak
dapat diakses oleh suatu objek dari luar kelas yang mendefinisikan bidang data
privat. Tetapi seringkali klien ingin memakai dan mengubah bidang data. Agar
bidang data privat dapat diakses, Anda bisa menyediakan suatu metode dapat untuk mendapatkan nilainya. Agar
bidang data privat dapat diperbarui, Anda juga bisa menyediakan suatu metode tetapkan untuk menetapkan suatu nilai
baru.
Suatu metode dapat memiliki sidik berikut ini:
public tipeNilaiBalik
dapatNamaData()
Suatu metode tetapkan memiliki sidik berikut ini:
public tipeNilaiBalik
tetapkanNamaData()
Jika tipeNilaiBalik adalah boolean,
metode dapat harus didefinisikan dengan konvensi berikut ini:
public boolean apaNamaData()
Suatu kelas lingkaran yang baru
dengan suatu bidang data privat dibuat, yang dinamakan Lingkaran3, untuk mengilustrasikan bagaimana enkapsulasi bidang
data bekerja. Kelas baru ini didefinisikan pada kode8.9:
Kode8.9 Lingkaran3.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
public class Lingkaran3 {
/** Radius lingkaran */
private double radius = 1;
/** Jumlah objek yang diciptakan */
private static int jumlahObjek = 0;
/** Menciptakan suatu lingkaran dengan
radius 1 */
public
Lingkaran3() {
jumlahObjek++;
}
/** Menciptakan suatu lingkaran dengan
radius tertentu */
public
Lingkaran3(double radiusBaru) {
radius = radiusBaru;
jumlahObjek++;
}
/** Memberikan nilai balik radius */
public double dapatRadius(){
return
radius;
}
/** Menetapkan nilai radius baru */
public void tetapkanRadius(double radiusBaru){
radius = (radiusBaru >= 0) ? radiusBaru
: 0;
}
/** Mengembalikan jumlahObjek */
public static int dapatJumlahObjek(){
return
jumlahObjek;
}
/** Mengembalikan luas lingkaran */
public
double dapatLuas() {
return
radius * radius * Math.PI;
}
}
|
Metode dapatRadius (baris 20-22) mengembalikan radius, dan metode tetapkanRadius (baris 25-27) menetapkan
suatu nilai radius yang baru kepada
objek. Jika nilai radius yang baru
negatif, maka nilai radius menjadi 0
kepada objek. Karena metode-metode ini satu-satunya jalan untuk mengakses dan
memodifikasi radius, maka Anda harus
memonitor dan mengendalikan bagaimana bidang data ini diakses. Jika Anda ingin
mengubah implementasi metode-metode ini, Anda tidak perlu mengubah program
klien. Hal ini membuat pemeliharaan kelas lebih gampang dilakukan.
Kode8.10 memberikan suatu program
klien yang menggunakan kelas Lingkaran3
untuk menciptakan suatu objek Lingkaran3,
lingkaranKu, dan memodifikasi radius
menggunakan metode tetapkanRadius.
Kode8.10 UjiLingkaran3.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class UjiLingkaran3 {
/** Metode utama */
public
static void main(String[] args) {
// Menciptakan suatu lingkaran dengan
radius 5.0
Lingkaran3 lingkaranKu = new Lingkaran3(5.0);
System.out.println("Luas lingkaran dengan radius "
+ lingkaranKu.dapatRadius() +
" adalah " + lingkaranKu.dapatLuas());
// Menambah radius lingkaranKu sebesar 10%
lingkaranKu.tetapkanRadius(lingkaranKu.dapatRadius()
* 1.1);
System.out.println("Luas lingkaran dengan radius "
+ lingkaranKu.dapatRadius() + " adalah " + lingkaranKu.dapatLuas());
System.out.println("Jumlah objek yang diciptakan adalah
"
+ Lingkaran3.dapatJumlahObjek());
}
}
|
Keluaran
Luas lingkaran dengan radius 5.0 adalah 78.53981633974483
Luas lingkaran dengan radius 5.5 adalah 95.03317777109125
Jumlah objek yang diciptakan adalah 1
Bidang data radius dideklarasikan privat. Data privat hanya bisa diakses dari
dalam kelas sendiri. Anda tidak bisa menggunakan lingkaranKu.radius dari suatu program klien. Suatu error kompilasi
akan terjadi bila Anda mencoba untuk mengakses data privat dari program klien.
Karena jumlahObjek dideklarasikan privat, maka tidak bisa dimodifikasi.
Hal ini menghindari pengubahan yang tidak diinginkan. Sebagai contoh, pengguna
tidak bisa menetapkan jumlahObjek
bernilai 100. Satu-satunya cara membuat jumlahObjek
bernilai 100 adalah dengan menciptakan 100 objek dari kelas Lingkaran3.
8.10 Melewatkan Objek Kepada
Metode
Anda bisa melewatkan objek kepada
metode. Seperti melewatkan array kepada metode, melewatkan objek sebenarnya
adalah melewatkan referensi objek. Kode berikut ini melewatkan objek lingkaranKu sebagai suatu argumen
kepada metode tampilLingkaran:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Uji {
public
static void main(String[] args) {
// Lingkaran3 didefinisikan dalam kode8.9
Lingkaran3 lingkaranKu = new Lingkaran3(5.0);
tampilLingkaran(lingkaranKu);
}
public
static void tampilLingkaran(Lingkaran3
c){
System.out.println("Luas lingkaran dengan radius "
+ c.dapatRadius() + " adalah " + c.dapatLuas());
}
}
|
JAVA menggunakan satu mode
pelewatan argumen: pelewatan dengan nilai. Pada kode sebelumnya, nilai lingkaranKu dilewatkan kepada metode tampilLingkaran. Nilai ini adalah suatu
referensi kepada suatu objek Lingkaran3.
Berikutnya akan didemonstrasikan
perbedaan antara pelewatan nilai primitif dengan pelewatan nilai referensi pada
kode 8.11:
Kode8.11 UjiPelewatanObjek.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class UjiPelewatanObjek {
/** Metode utama */
public
static void main(String[] args) {
// Menciptakan suatu objek Lingkaran3
dengan radius 1
Lingkaran3 lingkaranKu = new Lingkaran3(1);
// Menampilkan luas lingkaran untuk radius
1, 2, 3, 4, dan 5.
int n = 5;
tampilLuas(lingkaranKu, n);
// Melihat lingkaranKu.radius dan kali
System.out.println("\n" + "Radius = " +
lingkaranKu.dapatRadius());
System.out.println("n = " + n);
}
/** Menampilkan suatu tabel luas dengan
radius */
public
static void tampilLuas(Lingkaran3
c, int kali){
System.out.println("Radius \t\tLuas");
while
(kali >= 1) {
System.out.println(c.dapatRadius() + "\t\t" + c.dapatLuas());
c.tetapkanRadius(c.dapatRadius() + 1);
kali--;
}
}
}
|
Keluaran
Radius Luas
1.0 3.141592653589793
2.0 12.566370614359172
3.0 28.274333882308138
4.0 50.26548245743669
5.0 78.53981633974483
Radius = 6.0
n = 5
Kelas Lingkaran3 didefinisikan pada kode8.9. Program melewatkan suatu
objek Lingkaran3, lingkaranKu, dan suatu nilai integer n untuk memanggil tampilLuas(lingkaranKu, n) pada baris 9, yang menampilkan suatu
tabel untuk radius 1, 2, 3, 4, dan 5.
Ketika melewatkan suatu argumen
tipe primitif, nilai argumen yang dilewatkan. Pada kasus ini, nilai n(5) dilewatkan kepada kali. Dalam
metode tampilLuas, isi kali diubah; tetapi hal ini tidak
berpengaruh kepada n.
Ketika melewatkan suatu argumen
tipe referensi, referensi objek yang dilewatkan. Pada kasus ini, c memuat suatu referensi kepada objek
yang juga direferensikan oleh lingkaranKu.
Oleh karena itu, mengubah data objek melalui c di dalam metode tampilLuas
akan berdampak sama dengan pengubahan data objek di luar metode tampilLuas melalui variabel lingkaranKu.
8.11 Array Objek
Pada Bab. 6, array dengan
elemen-elemen primitif diciptakan. Anda juga bisa menciptakan array objek.
Sebagai contoh, statemen berikut ini mendeklarasikan dan menciptakan suatu
array yang memuast sepuluh objek Lingkaran:
Lingkaran[]
arrayLingkaran = new Lingkaran [10];
Untuk menginisialisasi arrayLingkaran, Anda bisa menggunakan
suatu loop for seperti ini:
for
(int i
= 0; i < arrayLingkaran.length; i++) {
arrayLingkaran [i] = new Lingkaran ();
}
Array objek merupakan suatu array
variabel referensi. Jadi, memanggil arrayLingkaran[1].dapatLuas()
melibatkan dua pereferensian, seperti ditunjukkan pada Gambar 8.16. arrayLingkaran mereferensi atau
menunjuk semua array. arrayLingkaran[1] mereferensi
suatu objek Lingkaran.
Gambar
8.16
Dalam suatu array objek, setiap elemen array memuat suatu referensi kepada
suatu objek
Kode8.12 memberikan suatu contoh
yang mendemonstrasikan bagaimana menggunakan suatu array objek. Program
menciptakan arrayLingkaran, suatu
array yang memuat 5 objek Lingkaran3,
menginisialisasi radius lingkaran dengan nilai acak dan menampilkan total luas
lingkaran di dalam array.
Kode8.12 TotalLuas.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
public class TotalLuas {
/** Metode utama */
public
static void main(String[] args) {
// Mendeklarasikan lingkaranArray
Lingkaran3[] arrayLingkaran;
// Menciptakan arrayLingkaran
arrayLingkaran = ciptaArrayLingkaran();
// Menampilkan arrayLingkaran dan total
luas lingkaran
tampilArrayLingkaran(arrayLingkaran);
}
/** Menciptakan suatu array yang memuat
objek-objek Lingkaran3 */
public
static Lingkaran3[] ciptaArrayLingkaran(){
Lingkaran3[] arrayLingkaran = new Lingkaran3[5];
for (int
i = 0; i < arrayLingkaran.length; i++) {
arrayLingkaran[i] = new Lingkaran3(Math.random() * 100);
}
// Mengembalikan array yang memuat
objek-objek Lingkaran3
return
arrayLingkaran;
}
/** Menampilkan suatu array Lingkaran3 dan
total luas */
public
static void tampilArrayLingkaran(Lingkaran3[]
arrayLingkaran){
System.out.printf("%-30s%-15s\n", "Radius", "Luas");
for
(int i = 0; i <
arrayLingkaran.length; i++) {
System.out.printf("%-30f%-15f\n",
arrayLingkaran[i].dapatRadius(),
arrayLingkaran[i].dapatLuas());
}
System.out.println("—————————————————————————————————————————");
// Menghitung dan menampilkan luas
System.out.printf("%-30s%-15f\n", "Total luas lingkaran adalah ",
jumlah(arrayLingkaran));
}
/** Menjumlahkan luas lingkaran */
public
static double jumlah(Lingkaran3[]
arrayLingkaran){
// menginisialisasi jum
double jum = 0;
// Menambah luas kepada jum
for
(int i = 0; i <
arrayLingkaran.length; i++)
jum += arrayLingkaran[i].dapatLuas();
return
jum;
}
}
|
Keluaran
Radius
Luas
78.759956
19487.709595
64.171537
12937.035172
98.967677
30770.647045
12.883886
521.487149
12.550941 494.882879
—————————————————————————————————————————
Total luas lingkaran adalah
64211.761840
Program memanggil ciptaArrayLingkaran (baris 8) untuk
menciptakan suatu array yang memuat lima objek Lingkaran3. Radius lingkaran secara acak dibangkitkan menggunakan
metode Math.random() pada baris 19.
Metode ciptaArrayLingkaran memberikan nilai balik berupa suatu array yang
memuat objek-objek Lingkaran3 (baris
23). Array tersebut dilewatkan kepada metode tampilArrayLingkaran, yang menampilkan radius dan luas setiap
lingkaran dan total luas keseluruhan lingkaran
Penjumlahan semua luas lingkaran
dihitung menggunakan metode jumlah
(baris 38), yang mengambil array objek Lingkaran3
sebagai argumen dan memberikan nilai balik total luas, jum, yang bertipe double.
No comments:
Post a Comment