7
Objek
dan Kelas
Kelas
merupakan inti dari Java. Kelas merupakan konstruksi logikal dimana bahasa
pemrograman Java dibangun. Kelas mendefinisikan objek. Setiap konsep yang akan diimplementasikan
di dalam suatu program Java harus dienkapsulasi di dalam sebuah kelas.
Soal dan
Penyelesaian
1.
Tulislah sebuah program sederhana dimana di dalamnya terdapat suatu
kelas Kotak.
Penyelesaian
class Kotak {
double lebar;
double tinggi;
double dalam;
}
// Kelas ini mendeklarasikan sebuah objek bertipe Kotak.
public class
DemoKotak {
public static void main(String args[]) {
Kotak kotakKu = new Kotak();
double vol;
// menugaskan nilai-nilai
kepada variabel-variabel instans kotakKu
kotakKu.lebar = 10;
kotakKu.tinggi = 20;
kotakKu.dalam = 15;
// menghitung volume kotak
vol = kotakKu.lebar *
kotakKu.tinggi * kotakKu.dalam;
System.out.println("Volume adalah " + vol);
}
}
Keluaran Program
Volume adalah 3000.0
2.
Setiap objek memiliki salinan dari setiap variabel instansnya sendiri. Ini
berarti bahwa jika Anda memiliki dua objek Kotak,
maka tiap objek memiliki salinan dari dalam,
lebar, dan tinggi. Hal ini penting dipahami bahwa perubahan yang terjadi pada
variabel instans dari satu objek tidak berpengaruh terharap variabel instans
dari objek lain. Tulislah sebuah program yang mengilustrasikan konsep ini.
Penyelesaian
//program ini mendeklarasikan dua objek Kotak
class Kotak {
double lebar;
double tinggi;
double dalam;
}
public class
DemoKotak2 {
public static void main(String args[]) {
Kotak kotakKu1 = new Kotak();
Kotak kotakKu2 = new Kotak();
double vol;
// menugaskan nilai-nilai kepada tiap variabel instans
dari objek kotakKu1
kotakKu1.lebar = 10;
kotakKu1.tinggi = 20;
kotakKu1.dalam = 15;
// menugaskan nilai-nilai kepada tiap variabel instans
dari objek kotakKu2
kotakKu2.lebar = 3;
kotakKu2.tinggi = 6;
kotakKu2.dalam = 9;
// menghitung volume untuk
kotak pertama
vol = kotakKu1.lebar *
kotakKu1.tinggi * kotakKu1.dalam;
System.out.println("Volume kotak1 adalah " + vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.lebar *
kotakKu2.tinggi * kotakKu2.dalam;
System.out.println("Volume kotak2 adalah " + vol);
}
}
Keluaran Program
Volume kotak1 adalah 3000.0
Volume kotak2 adalah 162.0
3.
Tulis program untuk menambahkan sebuah metode sederhana pada kelas Kotak pada soal no. 2.
Penyelesaian
//program ini mendeklarasikan dua objek Kotak
class Kotak {
double lebar;
double tinggi;
double dalam;
// menampilkan volume sebuah
kotak
void volume() {
System.out.print("Volume adalah ");
System.out.println(lebar *
tinggi * dalam);
}
}
public class
DemoKotak3 {
public static void
main(String args[]) {
Kotak kotakKu1 = new Kotak();
Kotak kotakKu2 = new Kotak();
double vol;
// menugaskan nilai-nilai kepada tiap variabel instans
dari objek kotakKu1
kotakKu1.lebar = 10;
kotakKu1.tinggi = 20;
kotakKu1.dalam = 15;
// menugaskan nilai-nilai kepada tiap variabel instans
dari objek kotakKu2
kotakKu2.lebar = 3;
kotakKu2.tinggi = 6;
kotakKu2.dalam = 9;
// menghitung volume untuk
kotak pertama
kotakKu1.volume();
// menghitung volume untuk
kotak kedua
kotakKu2.volume();
}
}
Keluaran Program
Volume adalah 3000.0
Volume adalah 162.0
4.
Tulis-ulanglah implementasi dari kode pada soal no 3 dimana metode volume merupakan metode yang
menghasilkan nilai balik.
Penyelesaian
//program ini mendeklarasikan dua objek Kotak
class Kotak {
double lebar;
double tinggi;
double dalam;
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
public class
DemoKotak4 {
public static void main(String args[]) {
Kotak kotakKu1 = new Kotak();
Kotak kotakKu2 = new Kotak();
double vol;
// menugaskan nilai-nilai kepada tiap variabel instans
dari objek kotakKu1
kotakKu1.lebar = 10;
kotakKu1.tinggi = 20;
kotakKu1.dalam = 15;
// menugaskan nilai-nilai kepada tiap variabel instans dari
objek kotakKu2
kotakKu2.lebar = 3;
kotakKu2.tinggi = 6;
kotakKu2.dalam = 9;
// menghitung volume untuk
kotak pertama
vol = kotakKu1.volume();
System.out.println("Volume kotak pertama adalah " +
vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.volume();
System.out.println("Volume kotak kedua adalah " +
vol);
}
}
Keluaran Program
Volume kotak pertama adalah 2000.0
Volume kotak kedua adalah 54.0
5.
Tulis-ulanglah kode pada soal no 4, dimana terdapat sebuah metode lain
untuk menetapkan dimensi-dimensi kotak. Konsep ini merupakan teknik pemrograman
yang lebih baik.
Penyelesaian
//program ini mendeklarasikan dua objek Kotak
class Kotak {
double lebar;
double tinggi;
double dalam;
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
// menetapkan dimensi-dimensi
sebuah kotak
void setDim(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
}
public class DemoKotak5 {
public static void main(String args[]) {
Kotak kotakKu1 = new Kotak();
Kotak kotakKu2 = new Kotak();
double vol;
// menginisialisasi setiap
kotak
kotakKu1.setDim(10, 20, 15);
kotakKu2.setDim(3, 6, 9);
// menghitung volume untuk
kotak pertama
vol = kotakKu1.volume();
System.out.println("Volume kotak pertama adalah " +
vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.volume();
System.out.println("Volume kotak kedua adalah " +
vol);
}
}
Keluaran Program
Volume kotak pertama adalah 2000.0
Volume kotak kedua adalah 54.0
6.
Sebuah konstruktor menginisialisasi objek ketika objek tersebut
diciptakan. Konstruktor memiliki nama sama dengan kelasnya dan secara sintaks
sama dengan metode. Konstruktor secara otomatis dipanggil setelah objek
diciptakan, sebelum operator new
dieksekusi. Konstruktor tidak dapat menghasilkan nilai balik, bahkan nilai
balik void. Satu-satunya tugas
konstruktor adalah menginisialisasi keadaan internal suatu objek sehingga kode
yang menciptakan sebuah objek menjadi terinisialisasi dan dapat digunakan.
Tulis-ulanglah kode pada soal no 5 sehingga
dimensi-dimensi kotak secara otomatis diinisialisasi ketika sebuah objek
diciptakan. Untuk melakukannya, Anda menggantikan metode setDim dengan sebuah konstruktor.
Penyelesaian
//program ini mendeklarasikan dua objek Kotak
class Kotak {
double lebar;
double tinggi;
double dalam;
// Ini merupakan konstruktor
untuk Kotak.
Kotak() {
System.out.println("Menciptakan Kotak");
lebar = 10;
tinggi = 10;
dalam = 10;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
public class
DemoKotak6 {
public static void
main(String args[]) {
Kotak kotakKu1 = new Kotak();
Kotak kotakKu2 = new Kotak();
double vol;
// menghitung volume untuk
kotak pertama
vol = kotakKu1.volume();
System.out.println("Volume kotak pertama adalah " +
vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.volume();
System.out.println("Volume kotak kedua adalah " +
vol);
}
}
Keluaran Program
Menciptakan Kotak
Menciptakan Kotak
Volume kotak pertama adalah 1000.0
Volume kotak kedua adalah 1000.0
7.
Tulis-ulanglah kode pada soal no 6, sehingga dapat menambahkan
parameter-parameter pada konstruktor.
Penyelesaian
//program ini mendeklarasikan dua objek Kotak
class Kotak {
double lebar;
double tinggi;
double dalam;
// Ini merupakan konstruktor
untuk Kotak.
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
public class
DemoKotak7 {
public static void
main(String args[]) {
Kotak kotakKu1 = new Kotak(10, 20, 15);
Kotak kotakKu2 = new Kotak(3, 6, 9);
double vol;
// menghitung volume untuk
kotak pertama
vol = kotakKu1.volume();
System.out.println("Volume kotak pertama adalah " +
vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.volume();
System.out.println("Volume kotak kedua adalah " +
vol);
}
}
Keluaran Program
Volume kotak pertama adalah 2000.0
Volume kotak kedua adalah 54.0
8.
Sebuah tumpukan menyimpan data dengan pengurutan FILO (first-in, last-out). Tulislah sebuah program untuk
mengimplementasikan tumpukan.
Penyelesaian
// Kelas ini mendefinisikan
sebuah tumpukan integer yang dapat menampung 10 nilai.
class Tumpukan {
int tumpukan[] = new int[10];
int tos;
// menginisialisasi atas
tumpukan
Tumpukan() {
tos = -1;
}
// Menempatkan sebuah item ke
atas tumpukan
void push(int item) {
if(tos==9)
System.out.println("Tumpukan
penuh.");
else
tumpukan[++tos] = item;
}
// Menghapus sebuah item dari
tumpukan
int pop() {
if(tos < 0) {
System.out.println("Tumpukan
kosong.");
return 0;
}
else
return tumpukan[tos--];
}
}
class UjiTumpukan {
public static void main(String args[]) {
Tumpukan tumpukan1 = new Tumpukan();
Tumpukan tumpukan2 = new Tumpukan();
// menempatkan beberapa
angka ke atas tumpukan
for(int i=0; i<10;
i++) tumpukan1.push(i);
for(int i=10; i<20;
i++) tumpukan2.push(i);
// menghapus beberapa angka dari tumpukan
System.out.println("Tumpukan di dalam tumpukan1:");
for(int i=0; i<10;
i++)
System.out.println(tumpukan1.pop());
System.out.println("Tumpukan di dalam tumpukan2:");
for(int i=0; i<10;
i++)
System.out.println(tumpukan2.pop());
}
}
Keluaran Program
Tumpukan di dalam tumpukan1:
9
8
7
6
5
4
3
2
1
0
Tumpukan di dalam tumpukan2:
19
18
17
16
15
14
13
12
11
10
9.
Dalam Java, adalah memungkinkan untuk mendefinisikan dua atau lebih metode
yang memiliki nama sama di dalam kelas yang sama, sepanjang deklarasi-deklarasi
parameternya berbeda. Ini dikenal dengan pengoverloadan metode. Pengoverloadan
metode merupakan salah satu cara dimana Java mendukung polimorfisme.
Ketika sebuah metode teroverload
dipanggil, Java menggunakan tipa dan/atau jumlah argumen untuk menentukan versi
metode teroverload mana yang dipanggil. Jadi, metode-metode teroverload hars
memiliki tipe dan/atau jumlah paramete yang berbeda.
Tulislah sebuah program yang memiliki
beberapa metode teroverload di dalam kelas yang sama.
Penyelesaian
// Mendemonstrasikan pengoverload metode.
class DemoOverload {
void test() {
System.out.println("Tidak ada parameter");
}
// Mengoverload test dengan satu
parameter integer.
void test(int a) {
System.out.println("a: " + a);
}
// Mengoverload test dengan dua
parameter integer.
void test(int a, int b) {
System.out.println("a dan b: " + a + " " +
b);
}
// Mengoverload test dengan satu
parameter double.
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
public class
MetodeOverloadKelas {
public static void main(String args[]) {
DemoOverload ob = new DemoOverload();
double hasil;
// memanggil ketiga versi
dari metode test()
ob.test();
ob.test(10);
ob.test(10, 20);
hasil = ob.test(123.25);
System.out.println("Hasil dari ob.test(123.25): " +
hasil);
}
}
Keluaran Program
Tidak ada parameter
a: 10
a dan b: 10 20
double a: 123.25
Hasil dari ob.test(123.25): 15190.5625
10.
Ketika sebuah metode teroverload dipanggil, Java akan mencari kecocokan
antara argumen-argumen yang dipakai untuk memanggil metode dan
parameter-parameter metode. Namun, kecocokan tidak selalu persis. Dalam
beberapa kasus, konversi tipe otomatis pada Java dapat berperan. Tulislah
sebuah program yang mengilustrasikan situasi ini.
Penyelesaian
// Mendemonstrasikan pengoverload metode.
class DemoOverload {
void test() {
System.out.println("Tidak ada parameter");
}
// Mengoverload test dengan dua
parameter integer.
void test(int a, int b) {
System.out.println("a dan b: " + a + " " +
b);
}
// Mengoverload test dengan satu
parameter double.
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
public class
MetodeOverloadKelas2 {
public static void main(String args[]) {
DemoOverload ob = new DemoOverload();
int i = 88;
// memanggil ketiga versi
dari metode test()
ob.test();
ob.test(10, 20);
ob.test(i); // ini akan
memanggil test(double)
ob.test(123.2); // ini akan
memanggil test(double)
}
}
Keluaran Program
Tidak ada parameter
a dan b: 10 20
double a: 88.0
double a: 123.2
11. Tulis-ulanglah
kode pada soal no 7, sehingga terdapat beberapa konstruktor teroverload.
Penyelesaian
/* Di sini, Kota mendefinisikan tiga konstruktor untuk menginisialisasi
dimensi-dimensi sebuah kotak
dengan beberapa cara.
*/
class Kotak {
double lebar;
double tinggi;
double dalam;
// konstruktor ini dipakai
ketika semua dimensi ditetapkan
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// konstruktor ini dipakai
ketika tidak ada dimensi ditetapkan
Kotak(){
lebar = -1; // menggunakan
-1 untuk mengindikasikan
tinggi = -1; // bahwa kotak
dalam = -1; // tidak
diinisialisasi
}
// konstruktor ini dipakai jika
semua sisi kotak sama
Kotak(double pjg) {
lebar = tinggi = dalam =
pjg;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
public class
KonstruktorKotakOverload {
public static void main(String args[]) {
// menciptakan kotak-kotak menggunakan
beberapa konstruktor
Kotak kotakKu1 = new Kotak(10, 20, 15);
Kotak kotakKu2 = new Kotak();
Kotak kubikKu = new Kotak(7);
double vol;
// menghitung volume untuk
kotak pertama
vol = kotakKu1.volume();
System.out.println("Volume kotak pertama adalah " +
vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.volume();
System.out.println("Volume kotak kedua adalah " +
vol);
// menghitung volume untuk
kubik
vol = kubikKu.volume();
System.out.println("Volume kubik adalah " + vol);
}
}
Keluaran Program
Volume kotak pertama adalah
2000.0
Volume kotak kedua adalah -1.0
Volume kubik adalah 343.0
12. Sejauh ini,
Anda hanya menggunakan tipe-tipe sederhana sebagai parameter-parameter pada
metode-metode. Tulislah sebuah program dimana dilewatkan objek kepada metode.
Penyelesaian
// Objek-objek dilewatkan kepada metode-metode.
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// menghasilkan true jika o sama
dengan objek pemanggil
boolean samaDengan(Test o) {
if(o.a == a && o.b == b) return true;
else return false;
}
}
public class
ParameterObjek {
public static void main(String args[]) {
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " +
ob1.samaDengan(ob2));
System.out.println("ob1 == ob3: " +
ob1.samaDengan(ob3));
}
}
Keluaran Program
ob1 == ob2: true
ob1 == ob3: false
13. Tulis-ulanglah
kode pada soal 11, sehingga Anda dapat menginisialisasi sebuah objek dengan
objek lainnya.
Penyelesaian
//Di sini, suatu objek dipakai untuk menginisialisasi objek lain
class Kotak {
double lebar;
double tinggi;
double dalam;
// Perhatikan konstruktor ini.
Ia mengambil sebuah objek bertipe Kotak.
Kotak(Kotak ob) { // melewatkan
objek kepada konstruktor
lebar = ob.lebar;
tinggi = ob.tinggi;
dalam = ob.dalam;
}
// konstruktor ini dipakai
ketika semua dimensi ditetapkan
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// konstruktor ini dipakai
ketika tidak ada dimensi ditetapkan
Kotak(){
lebar = -1; // menggunakan
-1 untuk mengindikasikan
tinggi = -1; // bahwa kotak
dalam = -1; // tidak
diinisialisasi
}
// konstruktor ini dipakai jika
semua sisi kotak sama
Kotak(double pjg) {
lebar = tinggi = dalam =
pjg;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
public class
InisialisasiObjekDenganObjekLain {
public static void main(String args[]) {
// menciptakan kotak-kotak
menggunakan beberapa konstruktor
Kotak kotakKu1 = new Kotak(10, 20, 15);
Kotak kotakKu2 = new Kotak();
Kotak kubikKu = new Kotak(7);
Kotak kloningKu = new Kotak(kotakKu1); // menciptakan salinan dari kotakKu1
double vol;
// menghitung volume untuk
kotak pertama
vol = kotakKu1.volume();
System.out.println("Volume kotak pertama adalah " +
vol);
// menghitung volume untuk
kotak kedua
vol = kotakKu2.volume();
System.out.println("Volume kotak kedua adalah " +
vol);
// menghitung volume untuk
kubik
vol = kubikKu.volume();
System.out.println("Volume kubik adalah " + vol);
// menghitung volume hasil
kloning
vol = kloningKu.volume();
System.out.println("Volume hasil kloning adalah " +
vol);
}
}
Keluaran Program
Volume kotak pertama adalah
2000.0
Volume kotak kedua adalah -1.0
Volume kubik adalah 343.0
Volume hasil kloning adalah
2000.0
14.
Tulislah sebuah program sederhana yang melewatkan sebuah tipe primitif
kepada suatu metode. Ini membuktikan bahwa pelewatan dilakukan dengan nilai. Jadi,
apa yang terjadi pada parameter yang menerima argumen tidak terpengaruh di luar
metode.
Penyelesaian
// Tipe-tipe primitif dilewatkan dengan nilai.
class Test {
void metode(int i, int j) {
i *= 2;
j /= 2;
}
}
public class
MetodePelewatanNilai {
public static void main(String args[]) {
Test ob = new Test();
int a = 15, b = 20;
System.out.println("a dan b sebelum pemanggilan metode:
" +
a + " " + b);
ob.metode(a, b);
System.out.println("a dan b sesudah pemanggilan metode: " +
a + " " + b);
}
}
Keluaran Program
a dan b sebelum pemanggilan metode: 15 20
a dan b sesudah pemanggilan metode: 15 20
15. Ketika Anda
melewatkan sebuah objek kepada suatu metode, situasinya berbeda secara
dramatis, karena objek dilewatkan dengan referensi. Perlu diingat bahwa ketika
Anda menciptakan sebuah variabel dari suatu tipe kelas, Anda hanya menciptakan
sebuah referensi yang menunjuk ke suatu objek. Jadi, ketika Anda melewatkan
referensi tersebut kepada suatu metode, parameter yang menerimanya akan
menunjuk ke objek sama yang ditunjuk oleh argumen. Ini berarti bahwa perubahan
yang terjadi pada objek di dalam metode akan berpengaruh pada objek yang
digunakan sebagai argumen.
Penyelesaian
// Objek-objek dilewatkan dengan referensi.
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// melewatkan suatu objek
void metode(Test o) {
o.a *= 2;
o.b /= 2;
}
}
public class
MetodePelewatanReferensi {
public static void main(String args[]) {
Test ob = new Test(15, 20);
System.out.println("ob.a dan ob.b setelah pemanggilan metode:
" +
ob.a + " " +
ob.b);
ob.metode(ob);
System.out.println("ob.a dan ob.b sebelum pemanggilan metode:
" +
ob.a + " " +
ob.b);
}
}
Keluaran Program
ob.a dan ob.b setelah pemanggilan metode: 15 20
ob.a dan ob.b sebelum pemanggilan metode: 30 10
16. Tulis dan
ujilah sebuah program yang memuat suatu metode yang menghasilkan nilai balik
berupa sebuah objek.
Penyelesaian
// Menghasilkan sebuah objek.
class Test {
int a;
Test(int i) {
a = i;
}
Test InkrSepuluh() {
Test temp = new Test(a+10);
return temp;
}
}
public class
NilaiBalikObjek {
public static void main(String args[]) {
Test ob1 = new Test(2);
Test ob2;
ob2 = ob1.InkrSepuluh();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);
ob2 = ob2.InkrSepuluh();
System.out.println("ob2.a setelah penambahan kedua: "
+ ob2.a);
}
}
Keluaran Program
ob1.a: 2
ob2.a: 12
ob2.a setelah penambahan kedua: 22
17. Java mendukung
adanya rekursi. Rekursi merupakan proses yang memampukan sebuah metode
memanggil dirinya sendiri. Tulis dan ujilah sebuah program yang
mengimplementasikan suatu metode rekursi.
Penyelesaian
// Sebuah contoh rekursi sederhana.
class Faktorial {
// Ini adalah metode rekursif
int fakt(int n) {
int hasil;
if(n==1) return 1;
hasil = fakt(n-1) * n;
return hasil;
}
}
public class
MetodeRekursi {
public static void main(String args[]) {
Faktorial f = new Faktorial();
System.out.println("Faktorial dari 3 adalah " + f.fakt(3));
System.out.println("Faktorial dari 4 adalah " +
f.fakt(4));
System.out.println("Faktorial dari 5 adalah " +
f.fakt(5));
}
}
Keluaran Program
Faktorial dari 3 adalah 6
Faktorial dari 4 adalah 24
Faktorial dari 5 adalah 120
18. Tulis dan
ujilah sebuah program yang mengimplementasikan suatu metode rekursi dan yang
melibatkan array.
Penyelesaian
// Contoh lain yang menggunakan rekursi.
class UjiRekursi {
int arrayNilai[];
UjiRekursi(int i) {
arrayNilai = new int[i];
}
// menampilkan array secara
rekursif
void tampilArray(int i) {
if(i==0) return;
else tampilArray(i-1);
System.out.println("[" + (i-1) + "] " + arrayNilai[i-1]);
}
}
public class
MetodeRekursiArray {
public static void main(String args[]) {
UjiRekursi ob = new UjiRekursi(10);
int i;
for(i=0; i<10; i++) ob.arrayNilai[i] = i;
ob.tampilArray(10);
}
}
Keluaran Program
[0] 0
[1] 1
[2] 2
[3] 3
[4] 4
[5] 5
[6] 6
[7] 7
[8] 8
[9] 9
19. Java memiliki
penspesifikasi akses public, private, dan protected. Penspesifikasi protected
dipakai hanya ketika pewarisan dilibatkan. Ketika suatu anggota kelas
ditetapkan public, maka anggota itu
dapat diakses oleh sembarang kode. Ketika suatu anggota kelas ditetapkan private, maka anggota itu hanya dapat
diakses oleh anggota-anggota lain dari kelas yang sama.
Jika tidak ada penspesifikasi akses
yang digunakan, maka anggota default suatu kelas adalah public di dalam paketnya sendiri, tetapi anggota itu tidak dapat
diakses di luar paketnya.
Tulislah sebuah program yang mendemonstrasikan
perbedaan antara penspesifikasi akses public
dan private.
Penyelesaian
//Program ini membedakan penspesifikasi akses public dan private
class Test {
int a; // akses default
public int b; // akses
public
private int c; // akses
private
// metode-metode untuk mengakses
c
void setc(int i) { //
menetapkan nilai c
c = i;
}
int getc() { // mendapatkan nilai c
return c;
}
}
public class PenspesifikasiAkses {
public static void main(String args[]) {
Test ob = new Test();
// Kedua statemen OK, karena
a dan b dapat diakses secara langsung
ob.a = 10;
ob.b = 20;
// Ini tidak OK karena
menyebabkan error
// ob.c = 100; // Error!
// Anda harus mengakses c
lewat metode-metodenya
ob.setc(100); // OK
System.out.println("a, b, dan c: " + ob.a + "
" +
ob.b + " " +
ob.getc());
}
}
Keluaran Program
a, b, dan c: 10 20 100
20. Untuk melihat
bagaimana kendali akses dapat diterapkan pada contoh yang lebih praktis,
tulis-ulanglah versi terperbaiki dari kelas Tumpukan yang diberikan pada Bab 7.
Penyelesaian
// Kelas ini mendefinisikan sebuah tumpukan integer dengan 10 nilai.
class Tumpukan {
/* Sekarang, kedua tmpkan dan
tos adalah private. Ini berarti
bahwa keduanya tidak dapat
secara langsung diubah secara tak sengaja
*/
private int tmpkan[] = new int[10];
private int tos;
// menginisialisasi atas tumpukan
Tumpukan() {
tos = -1;
}
// menempatkan sebuah item di
atas tumpukan
void push(int item) {
if(tos==9)
System.out.println("Tumpukan
penuh.");
else
tmpkan[++tos] = item;
}
// menghapus sebuah item dari
tumpukan
int pop() {
if(tos < 0) {
System.out.println("Tumpukan
kosong.");
return 0;
}
else
return tmpkan[tos--];
}
}
public class
KelasTumpukanTerperbaiki {
public static void main(String args[]) {
Tumpukan tumpukanKu1 = new Tumpukan();
Tumpukan tumpukanKu2 = new Tumpukan();
// menempatkan beberapa
angka ke atas tumpukan
for(int i=0; i<10;
i++) tumpukanKu1.push(i);
for(int i=10; i<20;
i++) tumpukanKu2.push(i);
// menghapus angka-angka
dari tumpukan
System.out.println("Tumpukan pada tumpukanKu1: ");
for(int i=0; i<10;
i++)
System.out.println(tumpukanKu1.pop());
System.out.println("Tumpukan pada tumpukanKu2: ");
for(int i=0; i<10;
i++)
System.out.println(tumpukanKu2.pop());
// kedua statemen berikut
tidak benar
// tumpukanKu1.tos = -2;
// tumpukanKu2.stck[3] =
100;
}
}
Keluaran Program
Tumpukan pada tumpukanKu1:
9
8
7
6
5
4
3
2
1
0
Tumpukan pada tumpukanKu2:
19
18
17
16
15
14
13
12
11
10
21. Ketika sebuah anggota
kelas dideklarasikan static, ia
dapat diakses ketika sembarang objek dari kelasnya diciptakan, dan tanpa
memerlukan referensi yang menunjuk ke sembarang objek. Anda dapat
mendeklarasikan metode dan variabel menjadi static. Contoh yang paling umum dijumpai dari anggota static adalah main. Metode main
dideklarasikan static karena ia
harus dipanggil sebelum sembarang objek diciptakan.
Variabel instans yang dideklarasikan static merupakan variabel global.
Ketika objek-objek dari kelasnya dideklarasikan, tidak ada salinan dari
variabel static yang diciptakan.
Semua instans (objek) dari kelas tersebut memakai variabel static yang sama.
Metode yang dideklarasikan static memiliki beberapa batasan:
·
Ia hanya dapat dipanggil oleh metode static lain.
·
Ia hanya bisa mengakses data static.
·
Ia tidak dapat menggunakan katakunci this atau super.
Katakunci super terkait dengan
pewarisan dan akan dijelaskan pada bab berikutnya.
Tulislah sebuah program yang memuat
variabel, metode, dan blok static.
Penyelesaian
// Mendemonstrasikan, variabel, metode, dan blok static.
class GunakanStatic {
static int a = 3;
static int b;
static void metode(int
x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Blok static diinisialisasi.");
b = a * 4;
}
public static void main(String args[]) {
metode(42);
}
}
Keluaran Program
Blok static diinisialisasi.
x = 42
a = 3
b = 12
22. Tulislah sebuah
program, dimana di dalam main,
metode static bernama panggilSaya dan sebuah variabel static bernama b diakses melalui nama kelasnya DemoStatic.
Penyelesaian
public class
DemoStatic {
static int a = 42;
static int b = 99;
static void
panggilSaya() {
System.out.println("a = " + a);
}
}
class StaticDgnNama {
public static void main(String args[]) {
DemoStatic.panggilSaya();
System.out.println("b = " + DemoStatic.b);
}
}
Keluaran Program
a = 42
b = 99
23. Anda dapat menggunakan
anggota length pada banyak situasi.
Tulis-ulanglah kelas Tumpukan yang
memanfaatkan length.
Penyelesaian
// Kelas ini menggunakan length.
class Tumpukan {
private int tmpkan[];
private int tos;
// mengalokasikan dan
menginisialisasi tumpukan
Tumpukan(int ukuran) {
tmpkan = new int[ukuran];
tos = -1;
}
// menempatkan sebuah item di
atas tumpukan
void push(int item) {
if(tos==tmpkan.length-1)
System.out.println("Tumpukan penuh.");
else
tmpkan[++tos] = item;
}
// menghapus sebuah item dari
tumpukan
int pop() {
if(tos < 0) {
System.out.println("Tumpukan
kosong.");
return 0;
}
else
return tmpkan[tos--];
}
}
public class
KelasTumpukanTerperbaikiDgnLength {
public static void main(String args[]) {
Tumpukan tumpukanKu1 = new Tumpukan(5);
Tumpukan tumpukanKu2 = new Tumpukan(8);
// menempatkan beberapa
angka ke atas tumpukan
for(int i=0; i<5;
i++) tumpukanKu1.push(i);
for(int i=0; i<8;
i++) tumpukanKu2.push(i);
// menghapus angka-angka
dari tumpukan
System.out.println("Tumpukan pada tumpukanKu1:
");
for(int i=0; i<5;
i++)
System.out.println(tumpukanKu1.pop());
System.out.println("Tumpukan pada tumpukanKu2:
");
for(int i=0; i<8;
i++)
System.out.println(tumpukanKu2.pop());
}
}
Keluaran Program
Tumpukan pada tumpukanKu1:
4
3
2
1
0
Tumpukan pada tumpukanKu2:
7
6
5
4
3
2
1
0
24. Adalah
memungkinkan untuk mendefinisikan sebuah kelas di dalam kelas lain; kelas
semacam itu dikenal dengan kelas bersarang. Skop dari sebuah kelas bersarang
dibatasi oleh skop dari kelas pemuat. Jadi, jika kelas B didefinisikan di dalam
kelas A, maka B tidak terbebas dari A. Kelas bersarang memang dapat mengakses
anggota-anggota dari kelas pemuat, termasuk anggota-anggota private. Namun, kelas pemuat tidak
dapat mengakses anggota-anggota dari kelas bersarang.
Tulislah sebuah program yang
mengilustrasikan bagaimana mendefinisikan dan menggunakan kelas bersarang.
Kelas Outer memiliki satu variabel
instans, outer_x, satu metode
instans, test, dan mendefinisikan
satu kelas inner, Inner.
Penyelesaian
// mendemonstrasikan kelas bersarang.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.tampil();
}
// ini adalah kelas bersarang
class Inner {
void tampil() {
System.out.println("menampilkan:
outer_x = " + outer_x);
}
}
}
public class
DemoKelasInnerOuter {
public static void main(String args[]) {
Outer outer = new Outer();
outer.test();
}
}
Keluaran Program
menampilkan: outer_x = 100
25. Seperti
dijelaskan sebelumnya, sebuah kelas bersarang memiliki akses terhadap semua
anggota dari kelas pemuatnya, tetapi kebalikannya tidak berlaku. Tulislah
sebuah program untuk mengilustrasikan situasi ini.
Penyelesaian
// program ini tidak dapat dikompilasi.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.tampil();
}
// ini adalah sebuah kelas
bersarang
class Inner {
int y = 10; // y adalah lokal pada Inner
void tampil() {
System.out.println("menampilkan:
outer_x = " + outer_x);
}
}
void tidakBisa() {
System.out.println(y); //
error, y tidak dikenal di sini!
}
}
public class
DemoKelasInnerOuter2 {
public static void main(String args[]) {
Outer outer = new Outer();
outer.test();
}
}
26. Anda dapat
mendefinisikan sebuah kelas bersarang di dalam blok yang didefinisikan oleh
suatu metode atau bahkan di dalam tubuh sebuah loop for. Tulislah sebuah program untuk mengilustrasikan situasi ini.
Penyelesaian
// mendefinisikan sebuah kelas bersarang di dalam loop for.
class Outer {
int outer_x = 100;
void test() {
for(int i=0; i<10;
i++) {
class Inner {
void tampil() {
System.out.println("menampilkan:
outer_x = " + outer_x);
}
}
Inner inner = new Inner();
inner.tampil();
}
}
}
public class
DemoKelasInnerOuter3 {
public static void main(String args[]) {
Outer outer = new Outer();
outer.test();
}
}
Keluaran Program
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
menampilkan: outer_x = 100
27. Suatu metode
dapat dipanggil dengan nol atau lebih argumen. Tulislah sebuah program untuk
mengilustrasikan situasi ini.
Penyelesaian
// mendemonstrasikan panjang argumen bervariasi.
public class
VariabelArgumen {
// vaTest() menggunakan panjang
variabel argumen.
static void vaTest(int ... v) {
System.out.print("Jumlah argumen: " + v.length +
", Isi: ");
for(int x : v)
System.out.print(x +
" ");
System.out.println();
}
public static void main(String args[]) {
// perhatikan bagaimana
vaTest() dapat dipanggil
// dengan banyak variabel
bervariasi.
vaTest(10); // 1 argumen
vaTest(1, 2, 3); // 3 argumen
vaTest(); // tanpa argumen
}
}
Keluaran Program
Jumlah argumen: 1, Isi: 10
Jumlah argumen: 3, Isi: 1 2 3
Jumlah argumen: 0, Isi:
28. Anda dapat mengoverload metode yang memiliki panjang
argumen bervariasi. Tulislah sebuah program untuk mengilustrasikan situasi ini.
Penyelesaian
// mengoverload metode dengan panjang argumen bervariasi.
public class
OverloadArgumenVariabel {
static void vaTest(int ... v) {
System.out.print("vaTest(int ...): " +
"Jumlah argumen: " + v.length +
" Isi: ");
for(int x : v)
System.out.print(x +
" ");
System.out.println();
}
static void vaTest(boolean ... v) {
System.out.print("vaTest(boolean ...) " +
"Jumlah argumen: " + v.length +
" Isi: ");
for(boolean x : v)
System.out.print(x +
" ");
System.out.println();
}
static void vaTest(String msg, int ... v) {
System.out.print("vaTest(String, int ...): " +
msg + v.length +
" Isi: ");
for(int x : v)
System.out.print(x +
" ");
System.out.println();
}
public static void main(String args[]) {
vaTest(1, 2, 3);
vaTest("Menguji: ", 10, 20);
vaTest(true, false, false);
}
}
Keluaran Program
vaTest(int ...): Jumlah argumen: 3 Isi: 1 2 3
vaTest(String, int ...): Menguji: 2 Isi: 10 20
vaTest(boolean ...) Jumlah argumen: 3 Isi: true false
false
No comments:
Post a Comment