Abstract Class dan Interface

Abstract Class
Abstract class (kelas abstrak) adalah kelas yang tidak dapat diinstansiasi
menjadi objek.
biasanya kelas abstrak digunakan pada hirarki kelas paling tinggi
induk dari semua kelas yang ada pada hirarki kelas yang dibuat
Kegunaan : untuk menggambarkan sistem secara keseluruhan.

Hirarki Kelas

Deklarasi Abstract Class

Metode kongkrit adalah metode yang memiliki badan (body) metode,
ditandai dengan tanda kurung kurawal buka-tutup ({}) setelah
mencantumkan nama metode
Metode kosong merupakan metode yang tidak memiliki tanda kurung
kurawal buka-tutup ({}).
Metode kosong abstrak
metode kosong yang dideklarasikan didalam kelas abstrak dan
terdapat kata kunci abstract pada metode tersebut
Metode kosong interface
metode kosong yang dideklarasikan didalam interface

Deklarasi Abstract Class (lanj.)

<modifier> abstract class
<NamaKelas>{
<deklarasiMetodeKosongAbstrak>*
<deklarasiMetodeKongkrit>*
}

* artinya bisa satu atau lebih deklarasi

<modifier> abstract <tipeData> <namaMetode>(<*argumen>);

public abstract class BangunDatar{
public abstract double luas();
public abstract void keliling(double x, double y);
}

Aturan Penggunaan Abstract Class

1.
2.
3.
4.
5.

Boleh memiliki kelas sub (keturunan).

Umumnya kelas abstrak menempati posisi hirarki tertinggi.
Kelas abstrak haruslah mendefinisikan metode-metode tanpa body .
Kelas abstrak boleh mendeklarasikan metode yang memiliki kongkrit.
Ketika kelas abstrak di extends, maka kelas sub wajib meng-override
semua metode abstract dari kelas abstrak tersebut.
6. Kelas abstrak tidak boleh diinstansiasi.
7. Jika kelas turunan kelas abstrak tidak meng-override salah satu atau
semua metode abstract, maka kelas sub tersebut akan berubah menjadi
kelas abstrak, sehingga tidak dapat diinstansiasi.

Penggunaan Abstract Class

abstract class BangunDatar{
//deklarasi metode kongkrit
public void cetak(){
System.out.println("\nIni adalah Kelas Abstrak");
}

//deklarasi metode abstrak

public abstract double luas();
public abstract double keliling();
}

Pewarisan Dari Abstract Class

TAMPILAN OUTPUT
abstract class BangunDatar{
//deklarasi metode kongkrit
public void cetak(){
System.out.println("\nIni adalah Kelas Abstrak");
}
//deklarasi metode abstrak
public abstract double luas();
public abstract double keliling();
}
class Persegi extends BangunDatar{
public double sisi;
public Persegi(double sisi){
this.sisi = sisi;
}
//Me-override metode abstrak
public double luas(){
return sisi*sisi;
}
public double keliling(){
return sisi*4;
}
}

class PersegiPanjang extends BangunDatar{

public double panjang;
public double lebar;
public PersegiPanjang(double panjang, double lebar){
this.panjang = panjang;
this.lebar = lebar;
}

//Me-override metode abstrak

public double luas(){
return panjang*lebar;
}
public double keliling(){
return (2*panjang)+(2*lebar);
}
}

Ini adalah Kelas Abstrak

Rumus Persegi
=====
Luas Persegi : 9.0
Keliling Persegi : 12.0
Ini adalah Kelas Abstrak
Rumus Persegi Panjang
=====
Luas Persegi Panjang : 35.0
Keliling Persegi Panjang : 24.0

class Program{
public static void main(String[] args){
Persegi psg = new Persegi(3);
PersegiPanjang psgpjg = new PersegiPanjang(5, 7);

psg.cetak();
System.out.println("Rumus Persegi\n=====");
System.out.println("Luas Persegi : "+ psg.luas());
System.out.println("Keliling Persegi : "+ psg.keliling());
psgpjg.cetak();
System.out.println("Rumus Persegi Panjang\n=====");
System.out.println("Luas Persegi Panjang : "+
psgpjg.luas());
System.out.println("Keliling Persegi Panjang : "+
psgpjg.keliling());
}
}

Interface
Interface adalah blok yang berisikan kumpulan metode kosong (tanpa
badan).
ketika sebuah kelas mengimplementasikan interface, maka kelas
tersebut tidak ada hubungan hirarki dengan interface yang
diimplementasi
Kegunaan interface adalah mengikat aturan kepada kelas-kelas, tanpa
terhubung dengan konsep pewarisan.

Deklarasi Interface
Metode kosong interface merupakan metode kosong yang dideklarasikan didalam blok interface
Metode kosong interface adalah metode yang tidak memiliki badan (body) metode, ditandai dengan
tanda kurung buka-tutup (()) setelah mencantumkan nama metode.
<modifier> interface <NamaInterface>{
<deklarasiAtributYangMemilikiNilaiInisialisasi>*
<deklarasiMetodeKosongInterface>*
}

* artinya bisa satu atau lebih deklarasi

Format pendeklarasian atribut dan metode abstrak :

<modifier> <tipeData>
<namaAtribut>(<*argumen>)=nilai;
<modifier> <tipeData>
<namaMetode>(<*argumen>);
* artinya bisa satu atau lebih deklarasi

public interface IntfCoba{

int atribut1 = 10;
public double atribut2 = 20.1;
void metode1(int a, double b);
public void metode2(String x, String y);
}

Aturan tentang pendeklarasian interface

1. Modifier yang dapat digunakan hanya public atau tidak sama sekali
(default)
2. Semua atribut yang dideklarasikan secara otomatis dianggap
sebagai static final.
3. Semua atribut yang dideklarasikan wajib diberi nilai awal.
4. Semua metode yang dideklarasikan merupakan metode kosong
interface. Perbedaan dengan metode kosong abstrak adalah kita
tidak menggunakan kata kunci abstract dalam membuat metode
kosong tersebut.
5. Semua interface tidak dapat dibuatkan objeknya.

Aturan Penggunaan Interface

1. Interface setara dengan kelas, sehingga aturan penamaannya sama
dengan kelas.
2. Ketika mengimplementasikan interface, maka kelas tersebut tidak
menjadi anak dari interface tersebut.
3. Bisa digunakan bersamaan dengan me-extends kelas.
4. Boleh mengimplementasikan lebih dari satu interface.
5. Interface berisikan metode-metode tanpa body (kosong), dan tidak boleh
ada metode isi/kongkrit.
6. Ketika kelas mengimplementasikan interface, maka kelas tersebut wajib
me-override semua metode kosong dari interface tersebut, jika tidak
maka program akan error.

Penggunaan Interface
public interface Hubungan{
public char perbandingan(double a, double b);
public boolean polindrom(String kata);
}

Penggunaan interface sama sekali tidak berguna jika

tidak ada kelas yang menggunakannya.
Interface haruslah diimplementasi oleh kelas biasa, ini
berfungsi untuk me-override perbandingan() dan
polindrom().

Gunakan kata kunci implements untuk meimplementasi interface.

<modifier> class <NamaKelas> implements <Interface>* {
<deklarasiAtibutMilikKelas>*
<deklarasiMetodeMilikKelas>*
<deklarasiMetodeMilikInterface>*
}

* artinya bisa satu atau lebih deklarasi

Satu kelas dapat mengimplementasi lebih dari satu interface.

Gunakan tanda koma (,) sebagai pemisah antar interface, jika
kelas tersebut mengimplementasi lebih dari satu interface.

Penggunaan Interface (lanj.)

public interface Hubungan{
public char perbandingan(double a, double b);
public boolean polindrom(String kata);

}
class PenggunaanHubungan implements Hubungan{
//Override metode kosong
public char perbandingan(double a, double b){
return (a>b)?'1':(b>a)?'2':'0';
}

class Program{
public static void cetakBanding(char banding){
if(banding=='1')
System.out.println("Nilai 1 lebih besar");
else if(banding=='2')
System.out.println("Nilai 2 lebih besar");
else
System.out.println("Nilai 1 dan 2 sama besar");
}
public static void cetakPolindrom(boolean hasilPolindrom){
if(hasilPolindrom)
System.out.println("merupakan POLINDROM");
else
System.out.println("merupakan BUKAN POLINDROM");
}
TAMPILAN OUTPUT

public boolean polindrom(String kata){

int a;
int poli = 0;
String kataUp = kata.toUpperCase();
for(a=0; a<kataUp.length(); a++)
if(kataUp.charAt(a)==kataUp.charAt(kataUp.length()-1-a))
poli++;
return (poli==kataUp.length())? true: false;
}
}

Nilai 1 : 80, Nilai 2 : 85

Nilai 2 lebih besar
-------------------------Nilai 1 : 85, Nilai 2 : 80
Nilai 1 lebih besar
-------------------------Nilai 1 : 85, Nilai 2 : 85
Nilai 1 dan 2 sama besar
-------------------------Kata : Kodok
merupakan POLINDROM
-------------------------Kata : Bangkong
merupakan BUKAN POLINDROM
--------------------------

public static void main(String[] args){

PenggunaanHubungan obj = new PenggunaanHubungan();
char hasilBanding;
boolean hasilPolindrom;
System.out.println("Nilai 1 : 80, Nilai 2 : 85");
hasilBanding = obj.perbandingan(80, 85);
cetakBanding(hasilBanding);
System.out.println("--------------------------");
System.out.println("Nilai 1 : 85, Nilai 2 : 80");
hasilBanding = obj.perbandingan(85, 80);
cetakBanding(hasilBanding);
System.out.println("--------------------------");
System.out.println("Nilai 1 : 85, Nilai 2 : 85");
hasilBanding = obj.perbandingan(85, 85);
cetakBanding(hasilBanding);
System.out.println("--------------------------");
System.out.println("Kata : Kodok");
hasilPolindrom = obj.polindrom("Kodok");
cetakPolindrom(hasilPolindrom);
System.out.println("--------------------------");
System.out.println("Kata : Bangkong");
hasilPolindrom = obj.polindrom("Bangkong");
cetakPolindrom(hasilPolindrom);
System.out.println("--------------------------");
}
}

Implementasi Interface Lebih Dari Satu

interface Interface1{
public String cetakStr1(String x);
public String cetakStr2(String x);
}
interface Interface2{
public String cetakInt1(int x);
public String cetakInt2(int x);
}

Catatan :
Berdasarkan contoh program, terlihat bahwa semakin banyak

interface yang diimplementasikan, maka semakin banyak pula

metode yang harus di-override.

class CetakInfo implements Interface1, Interface2{

//override semua metode dari Interface1 dan Interface2
public String cetakStr1(String x){
return "Cetak String 1 : "+ x;
class Program{
}
public static void main(String[] args){
public String cetakStr2(String x){
CetakInfo cetak = new CetakInfo();
return "Cetak String 2 : "+ x;
System.out.println(cetak.cetakStr1("Halo Bandung"));
}
System.out.println(cetak.cetakStr2("Halo Jakarta"));
public String cetakInt1(int x){
System.out.println(cetak.cetakInt1(12));
return "Cetak Integer 1 : "+ x;
System.out.println(cetak.cetakInt2(7));
TAMPILAN OUTPUT
}
}
public String cetakInt2(int x){
}
Cetak String 1 : Halo Bandung
return "Cetak Integer 2 : "+ x;
Cetak String 2 : Halo Jakarta
}
Cetak Integer 1 : 12
}
Cetak Integer 2 : 7

Extends Kelas Abstrak

dan Implementasi Interface
abstract class KelasAbstrak{
public abstract void cetakKata(String kata);
}
interface Interface1{
public String cetakStr1(String x);
public String cetakStr2(String x);
}
interface Interface2{
public String cetakInt1(int x);
public String cetakInt2(int x);
}
TAMPILAN OUTPUT
Kata : Memanggil cetakKata()
Cetak String 1 : Halo Bandung
Cetak String 2 : Halo Jakarta
Cetak Integer 1 : 12
Cetak Integer 2 : 7

class CetakInfo extends KelasAbstrak implements Interface1, Interface2{

//override metode dari KelasAbstrak
public void cetakKata(String kata){
System.out.println("Kata : "+ kata);
}
//override semua metode dari Interface1 dan Interface2
public String cetakStr1(String x){
return "Cetak String 1 : "+ x;
class Program{
}
public static void main(String[] args){
public String cetakStr2(String x){
return "Cetak String 2 : "+ x;
CetakInfo cetak = new CetakInfo();
}
cetak.cetakKata("Memanggil cetakKata()");
public String cetakInt1(int x){
return "Cetak Integer 1 : "+ x;
System.out.println(cetak.cetakStr1("Halo Bandung"));
}
System.out.println(cetak.cetakStr2("Halo Jakarta"));
public String cetakInt2(int x){
return "Cetak Integer 2 : "+ x;
System.out.println(cetak.cetakInt1(12));
}
System.out.println(cetak.cetakInt2(7));
}
}
}

Pewarisan Antar Interface

Aturan dari penggunaan konsep pewarisan antar interface :
1. Gunakan kata kunci extends sebagai penghubung antara super
interface dan sub interface.
2. Interface hanya boleh memiliki interface sebagai induknya,
sehingga kelas tidak boleh menjadi induk dari interface begitu pula
sebaliknya.

Pewarisan Antar Interface (lanj.)

interface A{
public void metode1();
public void metode2();
}
interface B extends A{ //Interface B adalah anak dari A
public void metode3();
public void metode4();
}
TAMPILAN OUTPUT
Menggunakan kelas PakaiA
Override metode 1
Override metode 2
-----------------------Menggunakan kelas PakaiB
Override metode 1
Override metode 2
Override metode 3
Override metode 4
------------------------

class PakaiB implements B{ //Lihat Interface yang digunakan

//override metode 1,2,3 dan 4
public void metode1(){
System.out.println("Override metode 1");
}
public void metode2(){
System.out.println("Override metode 2");
class Program{
}
public static void main(String[] args){
public void metode3(){
PakaiA a = new PakaiA();
System.out.println("Override metode 3");
System.out.println("Menggunakan kelas PakaiA");
}
a.metode1();
public void metode4(){
a.metode2();
System.out.println("Override metode 4");
System.out.println("------------------------");
}
}
PakaiB b = new PakaiB();
System.out.println("Menggunakan kelas PakaiB");
class PakaiA implements A{
b.metode1();
//override metode 1 dan 2
b.metode2();
public void metode1(){
b.metode3();
System.out.println("Override metode 1");
b.metode4();
}
System.out.println("------------------------");
public void metode2(){
}
System.out.println("Override metode 2");
}
}
}

Perbedaan Abstract Class dan Interface

Abstract Class

Interface

Masih boleh memiliki metode isi/kongkrit

Gunakan
kata
kunci extends
untuk
penggunaannya
Ketika di-extends, maka semua metode
kosong harus di-override, jika tidak maka kelas
tersebut akan berubah menjadi Abstract Class
Satu kelas hanya bisa me-extends satu Kelas
Biasa atau Kelas Abstrak
Tidak dianjurkan menggunakan pewarisan
kelas abstrak, karena seharusnya kelas abstrak
merupakan kelas yang menempati posisi
hirarki tertinggi

Hanya boleh berisi metode kosong

Gunakan kata kunci implements untuk
penggunaannya
Ketika di-implements, maka semua metode
kosong harus di-override, jika tidak maka
program akan error
Satu kelas bisa meng-implements lebih dari
satu interface
Boleh menggunakan pewarisan antar interface
dengan menggunakan kata kunci extends
sebagai penghubung antara super interface
dan sub interface