Pertemuan 4 Abstract Class, Interface dan Inner Class

Abstract Class, Interface dan Inner Class

1.   Abstract Class

Class Abstrak tidak berbeda dengan class – class lainnya yaitu memiliki class members (method dan variabel). Sebuah class adalah abstrak jika salah satu methodnya dideklarasikan abstrak. Method abstrak adalah method yang tidak memiliki implementasi.

Contoh deklarasi method abstrak:

abstract public void cetak();

Beberapa hal yang perlu diperhatikan adalah sebagai berikut:

1. Class abstrak tidak dapat dibuatkan instan atau objeknya menggunakan keyword new.
2. Sebuah class dapat dideklarasikan sebagai class abstrak walaupun tidak memiliki method abstrak.
3. Variabel dengan tipe class abstrak tetap bisa diciptakan, tetapi harus refer ke subclass dari class abtrak tersebut yang tentunya tidak abstrak.

Perhatikan contoh class abstrak di bawah ini.

abstrak public class Mobil {
 public void injakPedalGas();
 public void injakRem(){
    System.out.println(“Mobil berhenti!”);
 }
}
public class Kijang extends Mobil{
 public void injakPedalGas(){
  System.out.println("Mobil Melaju dengan kecepatan 80 Km/jam...");
 }
}
public class BMW extends Mobil {
   public void injakPedalGas(){
    System.out.println("Mobil Melaju dengan kecepatan 100 Km/jam...");
 }
}

Objek class abtrak tidak dapat diciptakan menggunakan keyword new secara langsung. Apabila kita terpaksa ingin menciptakan object class abtrak tanpa membuat subclass kongkritnya, maka kita harus mengimplementasikan method – method abstraknya secara langsung saat deklarasi. Perhatikan contoh di bawah ini.

public class TestMobil {
 public static void main(String[] args){
  Mobil mobil = new Mobil(){
   public void injakPedalGas(){
    System.out.println("Mobil berjalan...");
   }
  };
 
  Kijang kijang = new Kijang();
  Escudo escudo = new Escudo();
  BMW bmw = new BMW();
 
  mobil.injakPedalGas();
 
  mobil = kijang;
  mobil.injakPedalGas();
 
  mobil = escudo;
  mobil.injakPedalGas();
 
  mobil = bmw;
  mobil.injakPedalGas();
 }
}

 2.  Interface 

                 Interface adalah jenis khusus dari blok yang hanya berisi method signature(atau constant ).  Interface mendefinisikan sebuah(signature) dari sebuah kumpulan method tanpa tubuh.

               Interface mendefinisikan sebuah cara standar dan umum dalam menetapkan sifat-sifat dari  class-class. Mereka menyediakan class-class, tanpa memperhatikan lokasinya dalam hirarki class, untuk mengimplementasikan sifat-sifat yang umum. Dengan catatan bahwa interface-interface juga menunjukkan polimorfisme, dikarenakan program dapat memanggil method interface dan versi yang tepat dari method yang akan dieksekusi tergantung dari tipe object yang melewati pemanggil method interface.

       2.2  Aturan- Aturan Dalam Interface

             Berikut ini adalah aturan yang harus dingat tentang pendeklarasian interface:

• Modifier yang digunakan hanya public atau tidak sama sekali. Jika tidak menggunakan modifier maka interface tersebut hanya dapat diakses dalam package yang sama.

• Semua variabel yang dideklarasikan dalam interface secara otomatis adalah static final. Karena itu waktu pendeklarasian harus diberikan nilai.

• Semua method adalah abstrak. Bedanya dengan class abstrak adalah kita tidak perlu menuliskan keyword abstract pada saat mendeklarasikan method dalam interface.

• Kita dapat mengimplementasikan lebih dari satu interface (multiple inheritance) dengan memisahkan nama dari setiap interface dengan tanda koma.

• Dapat terjadi saat kita mengimplementasikan lebih dari satu interface ternyata interface – interface tersebut memiliki method yang sama. Dalam hal ini method yang akan diimplementasi adalah method yang berada pada posisi pertama.

• Semua method yang diimplemetasikan harus public.

•  Jika kita tidak mengimplementasikan semua method yang ada pada interface, maka class tersebut harus dideklarasikan sebagai abstract class.

 Pembuatan Interface sebenarnya mirip dengan pembuatan sebuah class. Pada saat kita  menggunakan kata kunci class, tetapi jika Interface, kata kunci yang digunakan adalah interface.

tingkat_akses interface nama_interface{

type-kembalian nama_method1(daftar-parameter);

type-kembalian nama_method2(daftar-parameter);

........

type-kembalian nama_methodN(daftar-parameter);

type variable final1 = nilai;

type variable final2 = nilai;

.......

type variable finalN = nilai;

}

Di sini tingkat_akses dapat diisi dengan public atau tidak. Apabila tingkat_akses tidak disertakan, maka interface yang didefinisikan tersebut hanya dapat dikenal sebagai kelas maupun interface-interface lain yang terdapat pada satu paket yang sama. Tetapi dideklarasikan public, maka class dan interface-interface yang terdapat pada paket lain juga dapat mengenalinya.

Berikut merupakan contoh interface sederhana dengan 3 method.

Interface alat_musik{

void mainkan( ); //secara otomatis bersifat public

void stelNada( );

String ambilNama( );

}

3. Inner Class

Inner class adalah suatu class yang berada di dalam class lainnya.

Ada 4 jenis inner class, yaitu :

            1. “Regular” Inner class

2. Method-local inner class

3. Anonymous inner class

                        4. Static nested classes

1. “Regular” Inner class

• Kata “Regular” di atas memiliki maksud bahwa inner class yang dibahas di sini adalah inner class yang bukan static / method-local / anonymous.
• Inner class didefinisikan (ditulis) di dalam kurung kurawal dari outer class.
• Bila ada kode java sebagai berikut :

Program 01

class MyOuter {       class MyInner {       } }

Dan kemudian dicompile dengan perintah :

%java MyOuter.java

Maka akan tercipta 2 buah file .class, yaitu : MyOuter.class dan MyOuter$MyInner.class.

• Instance inner class memiliki akses ke semua member dari outer class (termasuk member outer class yang ber access modifier private).

Contoh : 

Program 02

class A {     private int x = 101;     class B {         void lakukanSesuatu() {             System.out.print("x = " + x);         }     } } public class BelajarInnerClass02 {     public static void main(String[] args) {         A a = new A();         A.B b = a.new B();         b.lakukanSesuatu();     } }

• Sebuah inner class tidak dapat memiliki member static.

Contoh : 

Program 03

class A {     class B {         static int a = 10; //error!!!     } }

• Untuk membuat instance dari inner class, kita harus memiliki instance dari outer class terlebih dahulu. Tidak ada  pengecualisan untuk aturan ini.
• Untuk membuat instance dari inner class, terdapat 2 cara, yaitu :

1.      Dari dalam outer class

2.      Dari luar outer class

·         Contoh membuat instance inner class dari dalam outer class :

Program 04

class A {     void buatInstanceKelasB() {         B b = new B();     }     class B {     } }

Dari contoh di atas, untuk dapat menjalankan method buatInstanceKelasB, harus terdapat instance dari kelas A terlebih dahulu. Dengan kata lain, untuk membuat instance inner class, harus terdapat instance dari outer class terlebih dahulu.

Maksud dari membuat instance inner class dari dalam outer  class tidak termasuk membuat instance dari dalam method static. Sebab method static tidak dapat menunjuk sesuatu yang tidak static. Untuk membuat instance inner class dari dalam method static, maka dipergunakan cara seperti ketika membuat instance inner class dari luar outer class.

• Contoh membuat instance inner class dari luar outer class  :

Program 05

class A {     class B {         void sesuatuDiKelasB() {             System.out.println("Hello, ini di method kelas B");         }     } } public class Contoh {     public static void main(String[] args) {         A a = new A();         A.B b = a.new B();         b.sesuatuDiKelasB();     } }

Program 05 di atas dapat disingkat menjadi :

Program 06

class A {f     class B {         void sesuatuDiKelasB() {             System.out.println("Hello, ini di method kelas B");         }     } } public class BelajarInnerClass04 {     public static void main(String[] args) {         A.B b = new A().new B();         b.sesuatuDiKelasB();     } }

Ketika kita ingin membuat instance dari method static dari outer class, maka cara di ataslah yang digunakan. Hal ini karena method static tidak memiliki reference this.

• Aturan inner class dalam hal mereferensi dirinya sendiri atau instance dari outer class adalah sebagai berikut :

1.      Untuk merujuk pada dirinya sendiri (instance dari inner class) dari dalam inner class, dapat digunakan referensi this atau NamaOuterClass.NamaInnerClass.this.

2.      Untuk merujuk pada instance dari outer classnya dari dalam inner class, dapat digunakan referensi NamaOuterClass.this.

Contoh :

Program 07

class A {     int i = 10;     class B {         int i = 11;         class C {             int i = 12;             void lakukanSesuatu() {                 System.out.println("A.this.i     = " + A.this.i);                 System.out.println("A.B.this.i   = " + A.B.this.i);                 System.out.println("A.B.C.this.i = " + A.B.C.this.i);                 System.out.println("this.i       = " + this.i);             }         }     } } public class BelajarInnerClass05 {     public static void main(String[] args) {         A.B.C c = new A().new B().new C();         c.lakukanSesuatu();     } }

• Modifier-modifier berikut dapat diberikan pada inner class :

1.  final

2.  abstract

3.  public

4.  protected

5.  private

6.      static (tapi dengan modifier ini, maka akan menjadi static nested class, bukan inner class).

7.  strictfp

• 2. Method-Local Inner Class

• Method-local inner class adalah inner class yang dideklarasikan di dalam method.

• Mendeklarasikan method-local inner class tidak berarti kita membuat instance dari class tersebut. Jadi, sebelum kita menggunakan inner class tersebut, kita harus membuat instancenya dari suatu tempat di dalam method dan setelah definisi inner class tersebut.

Contoh :

Program 08

class A { //1     void myMethod() { //2         class B { //3             int i = 10;             void lakukanSesuatu() { //4                 System.out.println(" i = " + i);             } //4         } //3                 B b = new B();         b.lakukanSesuatu();     } //2 } //1

• Method-local inner class hanya dapat diinstansiasi dari dalam method yang mendefinisikan method-local inner class tersebut.
• Instance method-local inner class memiliki akses ke semua member dari outer class (termasuk member outer class yang ber access modifier private).

Contoh :

Program 09

class A { //1     private int i = 10;     void lakukanSesuatu() { //2         class B { //3             void aksesMemberOuterClass() { //4                 System.out.println("i = " + i);             } //4         } //3                 B b = new B();         b.aksesMemberOuterClass();     } //2 } //1

• Instance dari method-local inner class tidak dapat mengakses local variabel (termasuk parameter) dari method dimana method-local inner class tersebut didefinisikan. Kecuali bila variabel tersebut bermodifier final.

Contoh :

Program 10

class A { //1     void lakukanSesuatu() { //2         int nonFinalVar = 10;         final int finalVar = 11;         class B { //3             void aksesLocalVar() { //4                 //ERROR                 System.out.println("nonFinalVar = " + nonFinalVar);                 //TIDAK ERROR                 System.out.println("finalVar = " + finalVar);             } //4         } //3                 B b = new B();         b.aksesLocalVar();     } //2 } //1

• Method-local inner class yang didefinisikan di dalam static method tidak dapat mengakses non-static member dari outer classnya.
• Modifier-modifier yang dapat diberikan pada method-local inner class adalah :

1.      abstract (tidak dapat digabung dengan final)

2.      final (tidak dapat digabung dengan abstract)

3. Anonymous Inner Class

• Anonymous inner class adalah suatu inner class yang dideklarasikan tanpa nama kelas.

• Anonymous inner class pasti adalah salah satu dari 2 hal berikut :

1.      Subclass dari suatu class yang telah dideklarasikan

2.      Kelas implementasi dari suatu interface

• Suatu anonymous inner class tidak dapat secara bersamaan menjadi subclass dari class yang telah dideklarasikan dan juga sebagai kelas implementasi dari suatu interface

• Tujuan utama dari anonymous inner class adalah mengoverride satu atau lebih method dari super classnya atau mengimplement semua method dari suatu interface.

• Anonymous inner class tidak dapat mengimplement lebih dari sebuah interface

• Anonymous inner class selalu dibuat sebagai bagian dari suatu statement.

• Contoh Anonymous inner class sebagai subclass :

Program 11

class A {     int i = 10;     void lakukanSesuatu() {         i--;         System.out.println("i = " + i);     } } public class BelajarAnonymous1 {    //1     public static void main(String[] args) {    //2         A a = new A() {   //3             void lakukanSesuatu() { //4                 i++;                 System.out.println("i = " + i);             }   //4         };  //3                 a.lakukanSesuatu();     }   //2 }   //1

Note: variabel referensi a di atas mereferensi ke suatu instance anonymous inner class yang merupakan subclass dari class A. Jadi, variabel referensi a bukan mereferensi ke instance dari kelas A.

• Contoh anonymous inner class sebagai implementasi suatu interface : 

Program 12

interface A {     public void doA(); } interface B extends A {     public void doB(); } public class BelajarAnonymous2 {     public static void main(String[] args) {         B b = new B() {             public void doA() {                 System.out.println("Ini method doA()");             }                         public void doB() {                 System.out.println("Ini method doB()");             }         };                 b.doA();         b.doB();     } }

• Anonymous inner class adalah salah satu bentuk dari polymorphisme, oleh karena itu, method yang dapat dipanggil dari anonymous inner class adalah method yang dideklarasikan di super class atau interfacenya (meskipun di dalam anonymous inner class dapat dideklarasikan method-method yang tidak ada di super class atau interfacenya).

Contoh :

Program 13

class A {     int i = 10;     void lakukanSesuatu() {         i--;         System.out.println("i = " + i);     } } public class BelajarAnonymous1 {     public static void main(String[] args) {         A a = new A() {             void lakukanSesuatu() {                 i++;                 System.out.println("i = " + i);             }                         //Di bawah ini adalah method yang tidak ada di class A             void newMethod() {                 System.out.println("Hallo, nama saya Anton");             }         };                 a.lakukanSesuatu(); //Tidak error         a.newMethod(); //ERROR !!!!!!!     } }

• Anonymous inner class dapat diletakkan sebagai argument dari suatu method. Contoh :

Program 14

class A {     void lakukanSesuatu() {         System.out.println("Ini isi aslinya");     } } class B {     static void demoAnonymousInnerClassSebagaiArgument(A a) {         a.lakukanSesuatu();     } } public class BelajarAnonymous3 {     public static void main(String[] args) {         B.demoAnonymousInnerClassSebagaiArgument(new A() {             void lakukanSesuatu() {                 System.out.println("Ini method di anonymous inner class");             }         });     } }

 

4. Static nested class

• Static nested class adalah inner class dengan modifier static.
• Static nested class sebenarnya bukan inner class, static nested class hanyalah top-level class yang di sarangkan di dalam class lain.
• Karena static, maka untuk membuat instance dari static nested class tidak diperlukan instance dari outer classnya. (tidak seperti regular inner class ataupun method-local inner class ).

Contoh :

Program 15

class A {     static class B {         void lakukanSesuatu() {             System.out.println("Hallo");         }     } } public class StaticNestedClass {     public static void main(String[] args) {         A.B b = new A.B(); //cara instansiasi static nested class         b.lakukanSesuatu();     } }

• Cara instansiasi static nested inner class adalah :

NamaOuterClass.NamaStaticNestedClass varRef = new NamaOuterClass.NamaStaticNestedClass()

• Static nested class tidak dapat mengakses non-static member dari outer classnya.

Contoh :

Program 16

class A {     int i = 10;     static class B {         void lakukanSesuatu() {             System.out.println("i = " + i);         }     } } public class StaticNestedClass2 {     public static void main(String[] args) {         A.B b = new A.B();         b.lakukanSesuatu();     }