Pembahasan INNER CLASS dan Anonymous Inner Class

No comments
  Bagian ini memberi Anda tinjauan ulang atas konsep yang sudah Anda pelajari di pelajaran pemrograman pertama. Inner class dan anonymous inner class sangatlah bermanfaat untuk GUI event handling.
yang pertama adalah INNER CLASS
a. INNER CLASS
  • 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

 BONUS DARI CODE APLIKASI MENUTUP WINDOW PAKEK INNER CLASS
============================================================

Contoh Menutup Window
import java.awt.*;
import java.awt.event.*;
class CloseFrame extends Frame{
Label label;
CloseFrame(String title) {
super(title);
label = new Label("Close the frame.");
this.addWindowListener(new CFListener());
}
void launchFrame() {
setSize(300,300);
setVisible(true);
}
class CFListener extends WindowAdapter {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(1);
}
}
public static void main(String args[]) {
CloseFrame cf = new CloseFrame("Close Window
Example");
cf.launchFrame();
}
}

========================================================
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)


NAH . .  yang selanjutnya adalah Anonymous Inner Class

b. Anonymous Inner Class

BONUS APLIKASI CLOSE WINDOWS ANONYMOUS INNER CLASS

================================================
import java.awt.*;
import java.awt.event.*;
class CloseFrame extends Frame{
Label label;
CloseFrame(String title) {
super(title);
label = new Label("Close the frame.");
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
dispose();
System.exit(1);
}
});
}
void launchFrame() {
setSize(300,300);
setVisible(true);
}
public static void main(String args[]) {
CloseFrame cf = new CloseFrame("Close Window Example");
cf.launchFrame();
}
}

=============================================

·         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 : [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 !!!!!!!
    }
}


  • Anonymous inner class dapat diletakkan sebagai argument dari suatu method. Contoh : [1]
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. [2]
  • Static nested class sebenarnya bukan inner class, static nested class hanyalah top-level class yang di sarangkan di dalam class lain. [2]
  • Karena static, maka untuk membuat instance dari static nested class tidak diperlukan instance dari outer classnya. [2] (tidak seperti regular inner class ataupun method-local inner class [1]).
Contoh : [1]
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 : [2]
NamaOuterClass.NamaStaticNestedClass varRef = new NamaOuterClass.NamaStaticNestedClass()

  • Static nested class tidak dapat mengakses non-static member dari outer classnya. [2]
Contoh : [1]
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();
    }
}


Sekian tutorial dari ane semoga ini semua bermanfaat bagi anda semua selamat mencoba dan semoga sukses selalu dan sampai bertemu di tutorial berikutnye .
Posted in:

0 komentar:

Posting Komentar