9
Paket
dan Antarmuka
Bab
ini akan mendiskusikan lewat soal dan penyelesaian tentang fitur Java yang
paling inovatif: paket dan antarmuka. Paket merupakan kontainer bagi kelas-kelas
yang dipakai untuk menjaga ruang nama (name
space) tetap tersekat. Sebagai contoh, sebuah paket memampukan Anda untuk
menciptakan sebuah kelas Universitas,
yang dapat Anda simpan di dalam paket Anda sendiri tanpa perlu khawatir bahwa
kelas itu akan berbenturan dengan kelas lain yang bernama Universitas yang disimpan di tempat lain.
Melalu penggunaan katakunci interface, Java memampukan Anda untuk
memisahkan abstraksi dari implementasi. Dengan menggunakan interface, Anda dapat menetapkan sehimpunan metode yang dapat
diimplementasikan oleh satu atau lebih kelas. Antarmuka itu sendiri tidak
mendefinisikan implementasi apapun. Meskipun antarmuka mirip dengan kelas
abstrak, antarmuka memiliki kapabilitas yang tidak dimiliki kelas abstrak: Sebuah
kelas dapat mengimplementasikan lebih dari satu antarmuka. Sebaliknya, sebuah
kelas hanya bisa mewarisi dari satu superkelas saja (baik superkelas abstrak
atau konkrit).
Operator-Operator
Aritmatik
1.
Tulislah sebuah program sederhana yang mengimplementasikan paket di
dalam Java.
Penyelesaian
package paketKu;
class Saldo {
String nama;
double sal;
Saldo(String n, double b) {
nama = n;
sal = b;
}
void tampil() {
if(sal<0)
System.out.print("--> ");
System.out.println(nama
+ ": Rp. " + sal);
}
}
public class
SaldoAkun {
public static void main(String args[]) {
Saldo sekarang[] = new Saldo[3];
sekarang[0] = new Saldo("RH. Sianipar", 50000.345);
sekarang[1] = new Saldo("Vivian Siahaan", 125000.456);
sekarang[2] = new Saldo("I Ketut Wiryajati", 345739.457);
for(int i=0; i<3;
i++) sekarang[i].tampil();
}
}
Keluaran Program
RH. Sianipar: Rp. 50000.345
Vivian Siahaan: Rp. 125000.456
I Ketut Wiryajati: Rp. 345739.457
2.
Kelas dan paket keduanya merupakan cara mengenkapsulasi ruang nama dan
skop dari variabel dan metode. Paket berperan sebagai kontainer untuk kelas dan
paket turunan lain. Kelas berperan sebagai kontainer untuk data dan kode. Kelas
merupakan unit abstraksi terkecil pada Java. Dari keterkaitan antara kelas dan
paket, Java mengkategorikan visibilitas berikut:
·
Subkelas-subkelas di dalam paket yang sama
·
Selain subkelas di dalam paket yang sama
·
Subkelas-subkelas pada paket-paket berbeda
·
Selain subkelas atau selain kelas yang tidak berada di dalam paket yang
sama.
Tabel berikut menyimpulkan interaksi
ini.
|
|
Private
|
Tanpa Pemodifikasi
|
Protected
|
Public
|
|
Kelas yang sama
|
Ya
|
Ya
|
Ya
|
Ya
|
|
Subkelas
pada paket yang sama
|
Tidak
|
Ya
|
Ya
|
Ya
|
|
Tak sub-kelas pada
paket yang sama
|
Tidak
|
Ya
|
Ya
|
Ya
|
|
Subkelas pada paket berbeda
|
Tidak
|
Tidak
|
Ya
|
Ya
|
|
Tak
subkelas pada paket berbeda
|
Tidak
|
Tidak
|
Tidak
|
Ya
|
Tulislah sebuah program untuk
mengilustrasikan situasi seperti ini.
Penyelesaian
Ini adalah file Proteksi.java
package p1;
public class
Proteksi {
int n = 1;
private int n_pri = 2;
protected int n_pro = 3;
public int n_pub = 4;
public Proteksi() {
System.out.println("konstruktor basis");
System.out.println("n = " + n);
System.out.println("n_pri = " + n_pri);
System.out.println("n_pro = " + n_pro);
System.out.println("n_pub = " + n_pub);
}
}
Ini adalah file Terderivasi.java
package p1;
public class
Terderivasi extends Proteksi {
Terderivasi() {
System.out.println("konstruktor terderivasi");
System.out.println("n = " + n);
// hanya untuk superkelas
//
System.out.println("n_pri = "4 + n_pri);
System.out.println("n_pro = " + n_pro);
System.out.println("n_pub = " + n_pub);
}
}
Ini adalah file PaketSama.java
package p1;
public class
PaketSama {
PaketSama() {
Proteksi p = new Proteksi();
System.out.println("konstruktor paket sama");
System.out.println("n = " + p.n);
// hanya untuk superkelas
//
System.out.println("n_pri = " + p.n_pri);
System.out.println("n_pro = " + p.n_pro);
System.out.println("n_pub = " + p.n_pub);
}
}
Ini adalah file Proteksi2.java
package p2;
public class
Proteksi2 extends p1.Proteksi{
Proteksi2() {
System.out.println("konstruktor terderivasi pada paket lain");
// hanya untuk superkelas
atau paket sama
//
System.out.println("n = " + n);
// hanya untuk superkelas
//
System.out.println("n_pri = " + n_pri);
System.out.println("n_pro = " + n_pro);
System.out.println("n_pub = " + n_pub);
}
}
Ini adalah file PaketLain.java
package p2;
public class
PaketLain {
PaketLain() {
p1.Proteksi p = new p1.Proteksi();
System.out.println("konstruktor paket lain");
// hanya untuk superkelas
atau paket sama
//
System.out.println("n = " + p.n);
// hanya untuk superkelas
//
System.out.println("n_pri = " + p.n_pri);
// hanya untuk superkelas,
subkelas, dan paket yang sama
// System.out.println("n_pro = " +
p.n_pro);
System.out.println("n_pub = " + p.n_pub);
}
}
Berikut adalah kode untuk menguji paket
p1:
// Demo paket p1.
package p1;
// menginstansiasi pelbagai kelas di dalam paket p1.
public class
DemoPaket1 {
public static void main(String args[]) {
Proteksi ob1 = new Proteksi();
Terderivasi ob2 = new Terderivasi();
PaketSama ob3 = new PaketSama();
}
}
Keluaran Program
konstruktor basis
n = 1
n_pri = 2
n_pro = 3
n_pub = 4
konstruktor basis
n = 1
n_pri = 2
n_pro = 3
n_pub = 4
konstruktor terderivasi
n = 1
n_pro = 3
n_pub = 4
konstruktor basis
n = 1
n_pri = 2
n_pro = 3
n_pub = 4
konstruktor paket sama
n = 1
n_pro = 3
n_pub = 4
Berikut adalah kode untuk menguji paket
p2:
// Demo paket p2.
package p2;
// menginstansiasi pelbagai kelas di dalam paket p2.
public class
DemoPaket2 {
public static void main(String args[]) {
Proteksi2 ob1 = new Proteksi2();
PaketLain ob2 = new PaketLain();
}
}
Keluaran Program
konstruktor basis
n = 1
n_pri = 2
n_pro = 3
n_pub = 4
konstruktor terderivasi pada paket lain
n_pro = 3
n_pub = 4
konstruktor basis
n = 1
n_pri = 2
n_pro = 3
n_pub = 4
konstruktor paket lain
n_pub = 4
3.
Tulislah sebuah program untuk mendemonstrasikan teknik dalam mengimpor
paket pada Java.
Penyelesaian
package PaketKu;
/* Sekarang, kelas Saldo, konstruktornya, dan metode tampil() nya
adalah public. Ini berarti bahwa
ketiganya dapat dipakai
oleh kode tak subkelas di luar
paketnya.
*/
public class
Saldo {
String nama;
double sal;
public Saldo(String n, double b) {
nama = n;
sal = b;
}
public void tampil() {
if(sal<0)
System.out.print("--> ");
System.out.println(nama
+ ": Rp. " + sal);
}
}
import PaketKu.*;
public class
UjiSaldo {
public static void main(String args[]) {
/* Karena Saldo adalah public,
Anda dapat menggunakan kelas Saldo
dan memanggil
konstruktornya. */
Saldo test = new Saldo("RH. Sianipar", 99000.88);
test.tampil(); // Anda juga
dapat memanggil tampil()
}
}
Keluaran Program
RH. Sianipar: Rp. 99000.88
4.
Ketika tidak ada penspesifikasi akses dicantumkan, maka akses menjadi
default, dan antarmuka hanya tersedia untuk anggota-anggot pada paket yang
sama. Ketika dideklarasikan public,
antarmuka dapat dipakai oleh sembarang kode. Pada kasus ini, antarmuka merupakan
satu-satunya antarmuka public di
dalam file, dan file tersebut harus memiliki nama sama dengan antarmuka.
Perhatikan bahwa tiap metode dideklarasikan tanpa tubuh di dalam antarmuka.
Metode diakhiri oleh titik-koma setelah daftar parameter. Metode ini adalah
metode abstrak. Setiap kelas yang mencantumkan antarmuka harus
mengimplementasikan semua metode yang ada di dalam antarmuka. Variabel dapat
dideklarasikan di dalam deklarasi antarmuka. Variabel tersebut secara implisit final dan static, yang berarti bahwa ia tidak dapat diubah oleh kelas
pengimplementasi. Variabel tersebut juga harus diinisialisasi. Semua metode dan
variabel di dalam antarmuka secara implisit adalah public.
Tulislah sebuah program yang
menggunakan antarmuka.
Penyelesaian
public interface
PanggilKembali {
void panggilkembali(int
param);
}
Ini merupakan kelas sederhana yang
mengimplementasikan antarmuka PanggilKembali.
public class
Klien implements PanggilKembali {
// mengimplementasikan antarmuka
PanggilKembali
public void
panggilkembali(int p) {
System.out.println("panggilkembali dipanggil dengan "
+ p);
}
}
Adalah diijinkan untuk kelas yang
mengimplementasikan antarmuka untuk mendefinisikan anggota-anggotanya sendiri.
Sebagai contoh, versi Klien berikut
mengimplementasikan metode panggilkembali
dan menambahkan metode metodeTakAntarmuka:
public class
Klien implements PanggilKembali {
// mengimplementasikan antarmuka
PanggilKembali
public void
panggilkembali(int p) {
System.out.println("panggilkembali dipanggil dengan "
+ p);
}
void metodeTakAntarmuka() {
System.out.println("Kelas yang mengimplementasikan antarmuka
" +
"bisa juga mendefinisikan anggota-anggota
lain.");
}
}
Kode berikut memanggil metode
panggilkembali melalui variabel referensi antarmuka:
public class
UjiAntarmuka {
public static void main(String args[]) {
PanggilKembali c = new Klien();
c.panggilkembali(42);
}
}
Keluaran Program
panggilkembali dipanggil dengan 42
Kode berikut menciptakan implementasi
kedua dari antarmuka PanggilKembali:
// implemantasi lain dari antarmuka PanggilKembali.
class KlienLain implements
PanggilKembali {
// mengimplementasikan antarmuka
PanggilKembali
public void
panggilkembali(int p) {
System.out.println("Versi lain dari panggilkembali");
System.out.println("p dikuadrat adalah " + (p*p));
}
}
public class
UjiAntarmuka2 {
public static void main(String args[]) {
PanggilKembali c = new Klien();
KlienLain ob = new KlienLain();
c.panggilkembali(42);
c = ob; // c sekarang
menunjuk ke objek KlienLain
c.panggilkembali(42);
}
}
Keluaran Program
panggilkembali dipanggil dengan 42
Versi lain dari panggilkembali
p dikuadrat adalah 1764
5.
Tulislah sebuah program untuk mengilustrasikan antarmukan bersarang.
Penyelesaian
// Contoh antarmuka bersarang.
// Kelas ini memuat sebuah antarmuka anggota.
class A {
// ini merupakan antarmuka
bersarang
public interface
AntarmukaBersarang {
boolean apaTidakNegatif(int x);
}
}
// B mengimplementasikan antarmuka bersarang.
class B implements
A.AntarmukaBersarang {
public boolean
apaTidakNegatif(int x) {
return x < 0 ? false
: true;
}
}
class DemoAntarmukaBersarang {
public static void main(String args[]) {
// menggunakan referensi
antarmuka bersarang
A.AntarmukaBersarang nif = new B();
if(nif.apaTidakNegatif(10))
System.out.println("10 tidak
negatif");
if(nif.apaTidakNegatif(-12))
System.out.println("ini
tidak akan ditampilkan");
}
}
Keluaran Program
10 tidak negatif
6.
Tulislah sebuah program aplikatif untuk mengimplementasikan tumpukan ukuran
tetap menggunakan antarmuka.
Penyelesaian
// Sebuah implementasi dari AntarmukaTumpukan dengan penyimpanan tetap.
class TumpukanTetap implements
AntarmukaTumpukan {
private int tmpkan[];
private int tos;
// mengalokasikan dan
menginisialisasi tumpukan
TumpukanTetap(int ukuran) {
tmpkan = new int[ukuran];
tos = -1;
}
// Menempatkan sebuah item ke
atas tumpukan
public void push(int item) {
if(tos==tmpkan.length-1) // menggunakan anggota length
System.out.println("Tumpukan
penuh.");
else
tmpkan[++tos] = item;
}
// Menghapus sebuah item dari
tumpukan
public int pop() {
if(tos < 0) {
System.out.println("Tumpukan kosong.");
return 0;
}
else
return tmpkan[tos--];
}
}
public class
UjiTumpukanTetap {
public static void main(String args[]) {
TumpukanTetap tumpukanKu1 = new TumpukanTetap(5);
TumpukanTetap tumpukanKu2 = new TumpukanTetap(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 beberapa 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
7.
Tulislah sebuah program aplikatif untuk mengimplementasikan tumpukan
ukuran dinamis menggunakan antarmuka.
Penyelesaian
// Sebuah implementasi dari AntarmukaTumpukan dengan penyimpanan dinamis.
class TumpukanDinamis implements AntarmukaTumpukan {
private int tmpkan[];
private int tos;
// mengalokasikan dan
menginisialisasi tumpukan
TumpukanDinamis(int ukuran) {
tmpkan = new int[ukuran];
tos = -1;
}
// Menempatkan sebuah item ke
atas tumpukan
public void push(int item) {
// jika tumpukan penuh,
mengalokasikan tumpukan yang lebih besar
if(tos==tmpkan.length-1)
{
int temp[] = new
int[tmpkan.length * 2]; // menggandakan ukuran
for(int i=0;
i<tmpkan.length; i++) temp[i] = tmpkan[i];
tmpkan = temp;
tmpkan[++tos] = item;
}
else
tmpkan[++tos] = item;
}
// Menghapus sebuah item dari
tumpukan
public int pop() {
if(tos < 0) {
System.out.println("Tumpukan
kosong.");
return 0;
}
else
return tmpkan[tos--];
}
}
public class
UjiTumpukanDinamis {
public static void main(String args[]) {
TumpukanDinamis tumpukanKu1
= new TumpukanDinamis(5);
TumpukanDinamis tumpukanKu2
= new TumpukanDinamis(8);
// menempatkan beberapa
angka ke atas tumpukan
for(int i=0; i<12;
i++) tumpukanKu1.push(i);
for(int i=0; i<20;
i++) tumpukanKu2.push(i);
// menghapus beberapa angka
dari tumpukan
System.out.println("Tumpukan pada tumpukanKu1:");
for(int i=0; i<12;
i++)
System.out.println(tumpukanKu1.pop());
System.out.println("Tumpukan pada tumpukanKu2:");
for(int i=0; i<20;
i++)
System.out.println(tumpukanKu2.pop());
}
}
Keluaran Program
Tumpukan pada tumpukanKu1:
11
10
9
8
7
6
5
4
3
2
1
0
Tumpukan pada tumpukanKu2:
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
8.
Tulislah sebuah program aplikatif untuk mengimplementasikan TumpukanTetap dan TumpukanDinamis melalui referensi antarmuka.
Penyelesaian
/* Menciptakan sebuah variabel antarmuka dan
mengakses tumpukan melalui
variabel itu.
*/
class UjiTumpukanKeduanya {
public static void
main(String args[]) {
AntarmukaTumpukan
tumpukanKu; // menciptakan variabel
referensi antarmuka
TumpukanDinamis ds = new TumpukanDinamis(5);
TumpukanTetap fs = new TumpukanTetap(8);
tumpukanKu = ds; // tumpukan
dinamis
// menempatkan beberapa
angka ke atas tumpukan
for(int i=0; i<12;
i++) tumpukanKu.push(i);
tumpukanKu = fs; // tumpukan
tetap
for(int i=0; i<8;
i++) tumpukanKu.push(i);
tumpukanKu = ds;
System.out.println("Nilai-nilai pada tumpukan dinamis:");
for(int i=0; i<12;
i++)
System.out.println(tumpukanKu.pop());
tumpukanKu = fs;
System.out.println("Nilai-nilai pada tumpukan tetap:");
for(int i=0; i<8;
i++)
System.out.println(tumpukanKu.pop());
}
}
Keluaran Program
Nilai-nilai pada tumpukan dinamis:
11
10
9
8
7
6
5
4
3
2
1
0
Nilai-nilai pada tumpukan tetap:
7
6
5
4
3
2
1
0
9.
Anda dapat menggunakan antarmuka untuk mengimpor konstanta-konstanta
pada banyak kelas dengan mendeklarasikan sebuah antarmuka yang memuat
variabel-variabel yang telah diinisialisasi dengan nilai-nilai yang diinginkan.
Ketika Anda mencantumkan antarmuka tersebut di dalam sebuah kelas, maka semua
nama variabel tersebut akan menjadi konstanta. (Ingat bahwa variabel yang
dideklarasikan di dalam antarmuka secara implisit static dan final).
Penyelesaian
import java.util.Random;
interface KonstantaBersama {
int TIDAK = 0;
int YA = 1;
int MUNGKIN = 2;
int TIDAKTAHU = 3;
int NANTI = 4;
int TIDAKMAU = 5;
}
class Pertanyaan implements
KonstantaBersama {
Random rand = new Random();
int bertanya() {
int prob = (int) (100 * rand.nextDouble());
if (prob < 30)
return TIDAK; // 30%
else if (prob < 60)
return YA; // 30%
else if (prob < 75)
return TIDAKTAHU; // 15%
else if (prob < 98)
return NANTI; // 13%
else
return TIDAKMAU; // 2%
}
}
class TanyaSaya implements KonstantaBersama {
static void jawab(int
hasil) {
switch(hasil) {
case TIDAK:
System.out.println("Tidak");
break;
case YA:
System.out.println("Ya");
break;
case MUNGKIN:
System.out.println("Mungkin");
break;
case TIDAKTAHU:
System.out.println("Tidak
Tahu");
break;
case NANTI:
System.out.println("Nanti");
break;
case TIDAKMAU:
System.out.println("Tidak
Mau");
break;
}
}
public static void main(String args[]) {
Pertanyaan q = new Pertanyaan();
jawab(q.bertanya());
jawab(q.bertanya());
jawab(q.bertanya());
jawab(q.bertanya());
}
}
Keluaran Program
Tidak
Ya
Ya
Tidak
10. Suatu antarmuka
dapat mewarisi dari antarmuka lain menggunakan katakunci extends. Tulislah suatu program untuk mengilustrasikan situasi ini.
Penyelesaian
// Satu antarmuka dapat mewariskan ke antarmuka lain.
interface A {
void metode1();
void metode2();
}
// B sekarang mencakup metode1() and metode2() -- dan menambahkan
metode3().
interface B extends
A {
void metode3();
}
// kelas ini harus mengimplementasikan antarmuka A dan B
class KelasKu implements B {
public void metode1() {
System.out.println("Mengimplementasikan metode1().");
}
public void metode2() {
System.out.println("Mengimplementasikan metode2().");
}
public void metode3() {
System.out.println("Mengimplementasikan metode3().");
}
}
class DemoPewarisanAntarmuka {
public static void main(String arg[]) {
KelasKu ob = new KelasKu();
ob.metode1();
ob.metode2();
ob.metode3();
}
}
Keluaran Program
Mengimplementasikan metode1().
Mengimplementasikan metode2().
Mengimplementasikan metode3().
No comments:
Post a Comment