SOAL
·
Modifikasi
program berdasarkan praktek abstrak.Tambahkan sebuah kelas yang berisi definisi
untuk menghitung luas dan keliling lingkaran,simpan dengan nama file
“Lingkaran.java”.Kemudian buat obyek
lingkaran pada method main() dan tampilkan hasilnya.
·
Modifikasi
program berdasarkan praktek interface.Tambahkan sebuah kelas yang berisi
definisi untuk menghitung luas dan keliling segitiga,simpan dengan nama file
“InterfaceSegitiga.java”.Kemudian pada method main() buat obyek segitiga dan
tampilkan hasilnya.
LANDASAN TEORI
1.
Abstrak
Class abstrak merupakan suatu bentuk
khusus dari class dimana class tersebut tidak dapat diinstansiasi dan digunakan
hanya untuk diturunkan ke dalam bentuk class konkret atau class abstrak
berikutnya.
Kelas abstrak dideklarasikan menggunakan keyword abstract.
Di dalam class absrak dapat dideklarasikan atribut dan method
sama sperti class konkret,namun ada juga method abstrak, yaitu suatu method
yang tidak mempunyai implementasi hanya memiliki deklarasi saja.
Contoh
public abstract class Animal {
privateintnumOfFoots;
private Color color;
publicabstract void walk();
publicabstract void sound();
}
public class Cat extends Animal {
public void walk() {
System.out.println("cat walks using 4
legs");
}
public void sound() {
System.out.println("miaouw");
}
}
public class Chicken extends Animal {
public void walk() {
System.out.println("chicken walks using 2 legs");
}
public void sound() {
System.out.println("kukuruyuk");
}
}
Pada kode
program di atas dideklarasikan kelas Animal yang abstrak, di mana didalamnya dideklarasikan
dua variabel yaitu num Of Foots dan color. Selainitu, juga dideklarasikan dua buah method,
yaitu walk(), dan sound().
Method di dalam kelas Animal tidak didefinisikan impelementasi method, dengan harapan bahwa obyek turunan hewan yang spesifik, seperti Chicken dan Cat akan menyediakan implementasinya
yang spesifik dengan kondisi masing-masinghewan.
Pada Contoh di atas, method abstrak walk() dan
sound() dalam kelas Animal diimplementasikan oleh kelas Chicken
dan Cat. Kelas abstrak juga boleh tidak memiliki method abstrak sebagaimana ditunjukkan pada contoh program berikut.
publicabstract
class Vehicle {
private String type;
public String getType() {
return type;
}
}
Apabila ada satu saja method yang dideklarasikan dalam sebuah kelas sebagai method abstrak, maka kelas tersebut harus dideklarasikan
abstract.
Method abstrak adalah method yang sudah dideklarasikan,
tetap ibelum diimplementasikan. Sebuah method ditulis dengan kata kunci
abstract ketika kelas turunan (subclass) di bawahnya menyediakan implementasi
method tersebut. Method abstrak ditandai dengan modifier abstract, tidak memiliki implementasi,
dan diakhiri dengan tanda titik koma ( ; ).
public void
myAbstractMethod();
2.
Interface
Interface mendefinisikan aturan perilaku (protocol
of behavior) yang dapat diimplementasikan oleh kelas manapun. Interfacemendefinisikansatu
set methodtanpamenyediakanimplementasinya. Sebuah kelas yang
mengimplementasi sebuah interface terikat kontrak oleh interface tersebut untuk mengimplementasi semua method yang ada di dalam interface. Dengan
kata lain, kelas tersebut terikat untuk meng-implementasikan perilaku tertentu yang tertulis dalam interface. Secara substansi, interface merupakan kumpulan dari method abstrak dan konstanta.
Interface memiliki kemiripan dengan kelas abstrak, di
mana keduanya memuat method abstrak. Perbedaan penting antara interface dan kelas abstrak adalah :
1. Sebuah interface tidak dapat membuat implementasi satu method pun, sementara kelas abstrak dapat membuat implementasi satu atau lebih method.
2. Sebuah kelas dapat mengimplementasi beberap ainterface, tetapi ia hanya dapatmeng-extends satu superclass.
3.
Interface bukan merupakan bagian dari hirarki kelas. Dua kelas yang
tidak berhubungan dalam jalur hirarki kelas dapat mengimplementasi interface yang
sama.
Contoh:
public class
InterfaceSample{
public static void
main(String[] args) {
InterfaceBujurSangkar
obyek1 = new InterfaceBujurSangkar(10);
System.out.println("Jenisnyaadalah:
"+
obyek1.getJenis());
System.out.println("Luas
bujur sangkar dengan sisi 10 = " +
obyek1.hitungLuas());
System.out.println("Kelilingnya = " +
obyek1.hitungKeliling());
}
}
public class
InterfaceBujurSangkar implements InterfaceBangunDatar {
private double sisi;
public String
getJenis(){
return JENIS;
}
publicInterfaceBujurSangkar(double
sisi) {
this.sisi = sisi;
}
public double
hitungLuas() {
returnsisi * sisi;
}
public double
hitungKeliling() {
return 4 * sisi;
}
}
public class
InterfaceSample{
public static
void main(String[] args) {
InterfaceBujurSangkar
obyek1 = new InterfaceBujurSangkar(10);
System.out.println("Jenisnyaadalah:
"+
obyek1.getJenis());
System.out.println("Luas
bujur sangkar dengan sisi 10 = " +
obyek1.hitungLuas());
System.out.println("Kelilingnya = " +
obyek1.hitungKeliling());
}
}
Listing
Program & Hasil Run Program
Abstrak:
Class Abstrak Sample
package abstraksample;
public class
AbstrakSample {
public static void main(String[] args) {
// TODO code application logic here
System.out.println("Bujur
Sangkar");
Bangun_Datar obyek1 = new
Bujur_Sangkar(10);
System.out.println("Luas bujur
sangkar dengan sisi 10 = " + obyek1.hitungLuas());
System.out.println("Kelilingnya =
" + obyek1.hitungKeliling());
System.out.println("===================================");
System.out.println("\n");
System.out.println("Lingkaran");
Bangun_Datar obyek2 = new Lingkaran(7);
System.out.println("Luas lingkaran
dengan jari-jari " +
obyek2.hitungLuas() );
System.out.println("Kelilingnya =
" + obyek2.hitungKeliling());
}
}
Class Bangun_Datar
package abstraksample;
public
abstract class Bangun_Datar {
public abstract double hitungLuas();
public abstract double hitungKeliling();
}
Class Bujur_Sangkar
package abstraksample;
public
class Bujur_Sangkar extends Bangun_Datar {
private
double sisi;
public Bujur_Sangkar(double sisi) {
this.sisi = sisi;
}
public double hitungLuas() {
return sisi * sisi;
}
public double hitungKeliling() {
return 4 * sisi;
}
}
Class Lingkaran:
package
abstraksample;
public
class Lingkaran extends Bangun_Datar{
private double jari_jari;
public Lingkaran(double jari_jari) {
this.jari_jari = jari_jari;
}
public double hitungLuas() {
return 3.14 * jari_jari * jari_jari;
}
public double hitungKeliling() {
return 2 * 3.14 * jari_jari;
}
}
Interface
Class interface sample
package
interfacesample;
public
class InterfaceSample {
public static void main(String[] args) {
// TODO code application logic here
System.out.println("Bujur Sangkar");
InterfaceBujurSangkar obyek1 = new
InterfaceBujurSangkar(10);
System.out.println("Jenisnya
adalah : " + obyek1.getJenis());
System.out.println("Luas bujur
sangkar dengan sisi 10 = " + obyek1.hitungLuas());
System.out.println("Kelilingnya =
" + obyek1.hitungKeliling());
System.out.println("\n");
System.out.println("Segitiga");
InterfaceSegitiga obyek2 = new
InterfaceSegitiga(2, 4, 6);
System.out.println("Jenisnya
adalah : " + obyek2.getJenis());
System.out.println("Luas segitiga
= " + obyek2.hitungLuas());
System.out.println("Keliling
segitiga = " + obyek2.hitungKeliling());
}
}
Class interfaceBangunDatar
package
interfacesample;
public
interface InterfaceBangunDatar {
static final String JENIS = "Bangun
Datar 2D";
public abstract double hitungLuas();
public abstract double hitungKeliling();
}
Class interfaceBujurSangkar
package
interfacesample;
public
class InterfaceBujurSangkar implements InterfaceBangunDatar {
private double sisi;
public
String getJenis() {
return JENIS;
}
public InterfaceBujurSangkar(double sisi) {
this.sisi =sisi;
}
public double hitungLuas() {
return sisi * sisi;
}
public double hitungKeliling() {
return 4 * sisi;
}
}
Class interfaceSegitiga
package
interfacesample;
public
class InterfaceSegitiga implements InterfaceBangunDatar{
private double sisi1, sisi2, sisi3;
public String getJenis() {
return JENIS;
}
public InterfaceSegitiga(double sisi1,
double sisi2, double sisi3) {
this.sisi1 = sisi1;
this.sisi2 = sisi2;
this.sisi3 = sisi3;
}
public double hitungLuas() {
return 0.5 * sisi1 * sisi2;
}
public double hitungKeliling() {
return sisi1 + sisi2 + sisi3;
}
}
Kesimpulan
1.
Abstract
Abstarct
terdapat dua jenis yaitu abstract memiliki method abstract dan method biasa
atau method tidak abstract . namun fungsi method abstract sama dengan gunanya
method pewarisan
2.
Interface
Interface merupakan class yang hanya berisi daklarasi method tanpa
meiliki implementasi dan semua properti yang dimilikinya bersifat final.
Interface mirip dengan class abstract , tetapi interface tidak terkait dengan
class hierarki
Daftar
Pustaka
Ø Tri.Asttuti.”Abstrac
& Interface”
Posting Komentar