Pertemua 4

Abstract Class, Interface, Inner Class

A.   Abstrak Class

Abstract class adalah kelas yang terletak pada posisi tertinggi pada hierarki kelas. Kelas ini digunakan sebagai basis bagi penurunan kelas lainnya, sehingga abstract class tidak dapat diinstansiasi secara langsung menjadi object. Suatu abstract class bisa mengandung method kongkrit dan/atau method abstract. Abstract method meruapakan suatu method yang tidak mempunyai badan method. Hanya berupa nama method dan parameter inputan method. Ketika suatu abstract class diturunkan/ di-extends, maka subclass harus mengimplementasikan semua method abstract pada parent/ base class. Jika tidak mengimplementasikan semua method abstract maka subclass harus dideklarasikan sebagai abstract class.

B.   Interface

Interface adalah kumpulan method yang hanya memuat deklarasi dan struktur method, tanpa detail implementasinya. Sedangkan detail dari method berada pada class yang mengimplementasikan interface tersebut. Interface digunakan bila Anda ingin mengaplikasikan suatu method yang spesifik, yang tidak diperoleh dari proses inheritance. Tipe data yang boleh pada interface hanya tipe datakonstan. Setelah mengetahui apa itu interface. Timbul pertanyaan Mengapa membutuhkan interface?

·         Memecahkan bagian yang rumit dan spesifik. Dengan menggunakan class atau interface oleh vendor maka dalam pembuatan perangkat lunak menjadi lebih cepat.

·         Keterbatasan inheritance pada Java. Interface menjawab kebutuhan untuk melakukan multiple inheritance

Apakah Interface = Abstract class ?

Ya menurut saya sih antara keduanya memiliki kemiripan, tapi tidak sama. Mirip bukan berarti sama kan? Terdapat beberapa perbedaan antara keduanya yaitu

·         Abstract class dapat memiliki tipe data dengan semua tipe data, sedangkan interface tipe datanya hanya berupa konstanta

·         Method pada abstract class dapat berupa method kongkrit dan method abstract. Sedangkan pada interface semua method harus berupa method abstract.

Contoh

GraphicObject.java

abstract class GraphicObject {
int x,y;
void moveTo(int newValueX, int newValueY)
{
x = newValueX;
y = newValueY;
}
abstract void drawShape();
abstract void resize();

}

Circle.java

public class Circle extends GraphicObject {
void resize()
{
System.out.println(“Circle Resize”);
}
void drawShape()
{
System.out.println(“Circle Shape”);
}
void posisition()
{
System.out.println(this.x+this.y);
}
}

Main.java

public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Circle Lingkaran = new Circle();
Lingkaran.moveTo(5,5);
Lingkaran.drawShape();
Lingkaran.resize();
Lingkaran.posisition();
}

}

C.     INNER CLASS

Innerclass adalah class yang di sisipkan didalam kelas yang lain. Fungsi kelas sisip ini adalah mendukung suatu proses yang akan dijalankan oleh kelas utama

  

·                     Inner class adalah suatu class yang berada di dalam class lainnya. ^[1]

·                     Di buku ^[2], disebutkan 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. ^[2]

·                     Inner class didefinisikan (ditulis) di dalam kurung kurawal dari outer class. ^[2]

·                     Bila ada kode java sebagai berikut : ^[2]

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). ^[2]

Contoh : ^[1]

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. [2]

Contoh : ^[1]

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. ^[2]

·                     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 : ^[1]

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  : ^[1]

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 : ^[1]

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 : ^[2]

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 : ^[1]

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 : ^[2]

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 ^[2].

·         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. ^[2].

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). ^[2]

Contoh : ^[1]

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.^[2]

Contoh : ^[2]

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 ^[2].

·                     Modifier-modifier yang dapat diberikan pada method-local inner class adalah : ^[2]

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. ^[2]

·         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. ^[2]

·         Tujuan utama dari anonymous inner class adalah mengoverride satu atau lebih method dari super classnya atau mengimplement semua method dari suatu interface. ^[2]

·         Anonymous inner class tidak dapat mengimplement lebih dari sebuah interface. ^[2]

·         Anonymous inner class selalu dibuat sebagai bagian dari suatu statement. ^[2]

·         Contoh Anonymous inner class sebagai subclass : ^[1]

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 : ^[1]

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 : ^[1]

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 !!!!!!!     } }