Java (Netbeans) - Abstract & Interface - Object Oriented Programming

MAKALAH
PRAKTIKUM
ABSTRACT & INTERFACE
PEMROGRAMAN BERORIENTASI
OBJECT
DISUSUN OLEH :
MELINA KRISNAWATI
12.12.0328
SI 12 F
STMIK AMIKOM PURWOKERTO

TAHUN AJARAN 2012 / 2013
SOAL ( STUDI KASUS )
J Modifikasi program berdasarkan praktek abstrak.
J Menambahkan sebuah kelas yang berisi definisi untuk menghitung luas dan keliling
lingkaran, simpan dengan nama file “lingkaran.java”. kemudian buat obyek lingkaran ada
method main() dan tampilkan hasilnya.
 Modifikasi program berdasarkan praktek inteface.
 Menambahkan sebuah kelas yang berisi definisi untuk menghitung luas dan keliling
segitiga, simpan dengan nama file “InterfaceSegitiga.java”. kemudian pada method
main() buat obyek segitiga tampilkan hasilnya.

LANDASAN TEORI
INTERFACE
Interface adalah class yang hanya berisi deklarasi method tanpa memiliki implementasi dan
semua property yang dimilikinya bersifat final. Interface mirip dengan abstrak.
Pada java, interface merupakan device yang digunakan untuk komunikasi antarobject berbeda
yang tidak memiliki hubungan apa pun. Interface bisa dikatakan sebagai protocol komunikasi
antarobject tersebut.
Interface merupakan mekanisme dimana kita dapat menentukan metode – metode yang harus
ada pada kelas. Interface hamper mirip dengan kelas abstrak, namun ada beberapa perbedaan
pada interface dan kelas abstrak.
1. Kelas abstrak bisa mengandung metode abstrak dan metode tidak abstrak, sedangkan
pada interface harus semua metode abstrak.
2. Kelas abstrak dapat memiliki atribut, sedangkan interface tidak boleh memiliki atribut.
3. Kelas abstrak digunakan oleh kelas lain menggunakan pewarisan ( extends ), sedangkan
interface menggunakan implementasi ( implements ).
Bentuk umum deklarasi :

[modifier] interface namaInterface [extends] [namaInterface1, namaInterface2,
namaInterfaceN]
{
//deklarasi konstanta
//deklarasi fungsi – fungsi abstrak
}
suatu class yang mengimplementasikan suatu interface, maka class tersebut menyediakan
SEMUA definisi fungsi abstrak yang ada di Interface tersebut.
Deklarasi :
[modifier] class namaKelas implements Interface1 [,Interface2, InterfaceN]
{
//Implementasi Method Abstrak
//Badan Class
}
ABSTRAK
Kelas abstrak merupakan kelas dimana memiliki metode – metode namun tidak dideklarasikan,
pendeklarasiannya terjadi ada kelas turunannya. Untuk membuat kelas abstrak sama dengan
membuat kelas biasanya, namun diawali dengan kunci abstract pada kelasnya dan diawali
dengan kata kunci abstract pada metode yang akan dibuat namun tidak akan dideklarasikan.
Metode yang abstract tidak perlu berisikan deklarasinya.
Menurut Sinaga (2004), dijelaskan bahwa Abstract Class adalah class yang tidak dapat
diinstantiasi. Dengan kata lain Objek Class tersbut tidak dapat dibuat. Suatu class menjadi class
Abstract apabila class tersebut paling tidak memiliki fungsi Abstract.
Perbedaan abstrak dengan interface :

1. Class Abstract dapat memiliki fungsi non abstract (fungsi yang memiliki definisi).
2. Class Abstract dapat memiliki deklarasi variable.
Deklarasi :
abstract class nama_class
{
//Delarasi variabel
public abstract nama_fungsi_abstrak (parameter);
//Deklarasi fungsi yang lain
}
PEMBAHASAN
ABSTRACT
Pada class BangunDatar :
Pada class ini berisikan Method Abstrak .
 Method Abstrak
public abstract double hitungLuas();
public abstract double hitungKeliling();
public abstract double HitungLuas();

Merupakan method yang tidak boleh menggunakan/memakai deklarasi.
Jika sebuah method abstrak diisi dengan deklarasi, maka akan error.
Pada class BujurSangkar dan Lingkaran :
Pada class ini berisikan extends, tipe data double, dan method.
 Extends
Untuk mewariskan kelas turunannya, supaya tidak memboroskan coding atau terlalu
banyak penulisan coding.
 Tipe data double
Tipe data ini digunakan untuk suatu jenis bilangan decimal. Tipe data dapat digunakan
sesuai dengan keinginan dan kebutuhan programmer.
 Method
Method tersebut adalah method biasa/method tidak abstrak, artinya boleh diinputkan
sebuah deklarasi.
Pada class AbstractSample :

Pada class main ini, berisikan suatu pemanggilan method beserta objek, dan deklarasi.
BangunDatar obyek1 = new BujurSangkar(10) {
};
namaclass objek
System.out.println("Luas bujur sangkar dengan sisi 10 = " +
obyek1.hitungLuas());
System.out.println("Kelilingnya ="+obyek1.hitungKeliling());
System.out.println("n");
INTERFACE
Pada class InterfaceBangunDatar :
Class ini sama saja dengan class bangundatar pada abstrak, karna hanya berisikan method
abstrak dan disitu terdapat tambahan kata kunci final.
Pada class InterfaceBujurSangkar dan InterfaceSegitiga :
Class inipun tidak jauh berbeda dengan class pada abstrak, hanya saja kelas abstrak
menggunakan extends untuk mewarisi kelas turunannya, sedangkan interface menggunakan
implements.
Pada class InterfaceSample :

Sama saja dengan main class abstrak. Didalamnya berisikan suatu pemanggilan method saja,
diikuti dengan deklarasinya.
LISTING PROGRAM DAN HASIL RUNNING
ABSTRACT
Class BangunDatar :
package abstractsample;
/**
*
* @author azuura
*/
public abstract class BangunDatar {

public abstract double HitungLuas();
public abstract double HitungKeliling();
}
Class BujurSangkar :
/**
*
* @author azuura
*/
public class BujurSangkar extends BangunDatar{
private double sisi;
public BujurSangkar(double sisi) {
this.sisi = sisi;
}
public double hitungKeliling() {

return 4 * sisi;
}
public double hitungLuas() {
return sisi * sisi;
}
public double HitungLuas() {
throw new UnsupportedOperationException("Not
supported yet.");
}
public double HitungKeliling() {
supported yet.");
}
}
Class Lingkaran :

/**
*
* @author azuura
*/
public class Lingkaran extends BangunDatar {
private double r;
public Lingkaran(double r) {
this.r = r;
}
public double HitungKeliling() {
return 2 * 3.14 * r;
}
public double HitungLuas() {
return 3.14 * r * r;
}
supported yet.");

}
supported yet.");
}
}
Class AbstractSample :
/**
*
* @author azuura
*/
public class AbstractSample {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
BangunDatar obyek1 = new BujurSangkar(10) {
};
System.out.println("Luas bujur sangkar dengan sisi 10 = "
+ obyek1.hitungLuas());

System.out.println("Kelilingnya = "
+ obyek1.hitungKeliling());
BangunDatar obyek2 = new Lingkaran(7) {
};
System.out.println("Luas Lingkaran dengan jari - jari 7
= " + obyek2.HitungLuas());
System.out.println("Kelilingnya
= " + obyek2.HitungKeliling());
}
}
INTERFACE
Class InterfaceBangunDatar :

/**
*
* @author azuura
*/
public interface InterfaceBangunDatar {
static final String JENIS = "Bangun Datar 2D";
}
Class InterfaceBujurSangkar :
/**
*
* @author azuura
*/
public class InterfaceBujurSangkar implements
InterfaceBangunDatar{
private double sisi;
public String getJenis(){
return JENIS;
}

public InterfaceBujurSangkar(double sisi){
this.sisi = sisi;
}
return sisi * sisi;
}
return 4 * sisi;
}
}
Class InterfaceSegitiga :
/**
*
* @author azuura
*/
public class InterfaceSegitiga implements InterfaceBangunDatar{
private double alas;
private double tinggi;
public String getJenis(){
return JENIS;
}
public InterfaceSegitiga(double alas, double tinggi){
this.alas = alas;

this.tinggi = tinggi;
}
return 2 * alas + tinggi;
}
return ((alas * tinggi)/2);
}
}
Class InterfaceSample :
/**
*
* @author azuura
*/
public class InterfaceSample {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
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());
InterfaceBangunDatar obyek2 = new InterfaceSegitiga(6,
8){};
System.out.println("Jenisnya adalah
= "+ obyek1.getJenis());
System.out.println("Luas Segitiga dengan alas 6, dan
tinggi 8 = "+ obyek2.hitungLuas());
System.out.println("Kelilingnya
= "+ obyek2.hitungKeliling());
}
}
KESIMPULAN
Kesimpulannya adalah bahwa Interface merupakan class yang hanya berisi deklarasi method
tanpa memiliki implementasi dan semua property yang dimilikinya bersifat final.

Interface mirip dengan class abstract, tetapi interface tidak terkait dengan class hierarki. Interface
mendefinisikan sebuah ( signature) dari sebuah kumpulan method tanpa tubuh.
Interface perlu digunakan dalam kerja team, karena programmer yang lain tidak perlu tahu
bagaimana detail code ditulis.
Kesimpulan dari abstrak adalah abstrak memiliki Method abstrak dan method biasa/method
tidak abstrak. Namun fungsi method abstrak sama dengan gunanya untuk pewarisan.
DAFTAR PUSTAKA
Khannedy, Eko Kurniawan. 2011. Belajar Java Dasar. StripBandunk
http://7seasons.wordpress.com

Java (Netbeans) - Abstract & Interface - Object Oriented Programming

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java (Netbeans) - Abstract & Interface - Object Oriented Programming (20)

More from Melina Krisnawati (19)

Java (Netbeans) - Abstract & Interface - Object Oriented Programming