MODUL XII,PBO 1

NESTED CLASS (KELAS DI DALAM KELAS)
 

TUJUAN:
Membuat kelas di dalam kelas dan penerapanya dalam aplikasi
TEORI SINGKAT:
Bentuk umum script program adalah sebagai berikut:
class OuterClass{
     …..
     Class NestedCalss{
     ….}
     }
}
PELAKSANAAN PRAKTIKUM:
Listing program 1. StrukturData.java
public class StrukturData{
//Ciptakan array
  private final static int SIZE=15;
  private int[] larikBulat=new int[SIZE];
  public StrukturData(){
       //Isi array dengan nilai bulat urut naik
       for (int i=0; i
             larikBulat[i]=i;
       }
  }
  public void printGenap(){
       //cetak nilai dari indeks genap dari array
       InnerIteratorGenap iterator=this.new InnerIteratorGenap();
       while (iterator.hasNext()){
             System.out.print(iterator.getNext() + ” “);
       }
       System.out.println();
  }
//inner class untuk implementasi pola Iterator
  private class InnerIteratorGenap{
       //Star mulai dari awal array
       private int lanjut=0;
       public boolean hasNext(){
             //cek apakah elemen sekaranga dalah elemen terakhir array
             return (lanjut<=SIZE-1);
       }
       public int getNext(){
             //ambil nilai dalam indeks genap dari array
             int hasil=larikBulat[lanjut];
             //teruska ke elemen indeks genap selanjutnya
             lanjut +=2;
             return hasil;
       }
  }
  public static void main(String[]args){
       //isi array dengan nilai bulat urut naik
       //dan cetak nilai pada indeks genap
       StrukturData sd=new StrukturData();
       sd.printGenap();
  }
}
Listing di atas adalah  contoh sebuah program java yang di dalamnya terdapat kelas juga. Ini mengartikan bahwa java selain memfasilitasi sub program / sub kelas juga memfasilitasinya dengan yang lebih besar lagi yaitu tidak hanya sub kelas tetapi memasilitasi release program di dalam program. Karena di dalam kelas ini juga terdapat variabel, konstruktor dan method yang berlainan.  Jika di dalam java ini ada method di dalam method maka juga ada kelas di dalam kelas. Adapun listing di atas dapat dijelaskan sebagai berikut:
Kelas luas yang ciciptakan adalah class strukturData yang mempunyai variabel private bertipe static yaitu SIZE dan private non static bertipe larikBulat. Mempunyai satu konstruktor yang digunakan untuk menentukan isi variabel array yang bernama larikBulat[] dengan angka dari 0 s/d 14.Kemudian ada satu buah method yang berfungsi sebagai method pencetak dengan nama printGenap(). Di dalam method ini terdapat satu fungsi pemanggil yang diinstanisasi dari kelas inner (nested class) bernama InnerIteratorGenap.
Membuat kelas inner tersebut sama seperti halnya pembuatan kelas-kelas biasa. Di dalam kelas inner tersebut terdapat  variabel lanjut, method hasNext() dengan return value boolean, dan method getNext() dengan return value integer bernama hasil.
Ternyata method-method inilah yang kemudian dipanggil dengan instaniasi objek yang diciptakan dari kelas inner yaitu objek iterator. Method  hasNext pada inner class dipanggil untuk menentukan suatu syarat while yang menyatakan bahwa apabila fungsi while bermakna benar maka operasi System.out.print dijalankan. Yang dicetak dari method ini adalah dari hasil return values method getNext() pula dna tentunya ini harus menggunakan objek iterator yang diisntaniasi oleh kelas InnerIteratorGenap sebagai inner kelas tersebut. Dengan demikian kita dapat mengetahui bahwa method di dalam kelas inner dengan mudahnya dapat kita panggil di dalam kelas luar.
Hasilnya adalah
Menambahkan kelas baru di dalam kelas:
//tambahan kelas static nested class (KELAS DI DALAM KELAS)
     static class Size{
       public int getSize(){
            return SIZE;
       }
           }
Menambah statemen penggunaan kelas di dalam kelas tersebut:
public static void main(String[]args){
       //isi array dengan nilai bulat urut naik
       //dan cetak nilai pada indeks genap
       StrukturData2 sd=new StrukturData2();
       sd.printGenap();
       //tambahan untuk memanggil kelas di dalam kelas
       StrukturData2.Size sd2=new StrukturData2.Size();
       System.out.println(sd2.getSize());
           }
Hasilnya adalah:
Menghilangkan modifier static pada kelas variabel SIZE
Dari:
           private final static int SIZE=15;
Menjadi:
           Private final int SIZE=15;
Hasilnya adalah:
E:\Semester 2\Object Oriented Programming 1\Modul12-Nested Class\StrukturData2.java:57: non-static variable SIZE cannot be referenced from a static context
            return SIZE;
                   ^
1 error
Tool completed with exit code 1
Membuat kelas InnerIteratorGanjil:
public class StrukturData2{
//Ciptakan array
     private final static int SIZE=15; //Hilangkan staticnya mejadi:
     //private final int SIZE=15; (hasilnya Error)
     private int[] larikBulat=new int[SIZE];
     public StrukturData2(){
       //Isi array dengan nilai bulat urut naik
       for (int i=0; i
            larikBulat[i]=i;
       }
     }
     public void printGenap(){
       //cetak nilai dari indeks genap dari array
       InnerIteratorGenap iterator=this.new InnerIteratorGenap();
       while (iterator.hasNext()){
            System.out.print(iterator.getNext() + ” “);
       }
       System.out.println();
     }
       public void printGanjil(){
            //cetak nilai dari indeks ganjil dari array
            InnerIteratorGanjil iterator=this.new InnerIteratorGanjil();
            while (iterator.hasNext()){
                  System.out.print(iterator.getNext() + ” “);
            }
            System.out.println();
       }
//inner class untuk implementasi pola Iterator
     private class InnerIteratorGenap{
       //Star mulai dari awal array
       private int lanjut=0;
       public boolean hasNext(){
            //cek apakah elemen sekaranga dalah elemen terakhir array
            return (lanjut<=SIZE-1);
       }
       public int getNext(){
            //ambil nilai dalam indeks genap dari array
            int hasil=larikBulat[lanjut];
            //teruska ke elemen indeks genap selanjutnya
            lanjut +=2;
            return hasil;
       }
     }
//Membuat Kelas InnerIteratorGanjil
     private class InnerIteratorGanjil{
       //Star mulai dari awal array
       private int lanjut=1;
       public boolean hasNext(){
            //cek apakah elemen sekarang adalah elemen terakhir array
            return (lanjut<=SIZE-1);
       }
       public int getNext(){
            //ambil nilai dalam indeks ganjil dari array
            int hasil=larikBulat[lanjut];
            //teruska ke elemen indeks ganjil selanjutnya
            lanjut +=2;
            return hasil;
       }
     }
//Membuat Kelas InnerIteratorString
     private class InnerIteratorString{
       //Star mulai dari awal array
       private int lanjut=1;
       public boolean hasNext(){
            //cek apakah elemen sekarang adalah elemen terakhir array
            return (lanjut<=SIZE-1);
       }
       public int getNext(){
            //ambil nilai dalam indeks genap dari array
            int hasil=larikBulat[lanjut];
            //teruska ke elemen indeks genap selanjutnya
            lanjut +=2;
            return hasil;
       }
     }
//===================================================
     public static void main(String[]args){
       //isi array dengan nilai bulat urut naik
       //dan cetak nilai pada indeks genap
       StrukturData2 sd=new StrukturData2();
       sd.printGenap();
       sd.printGanjil();
       //tambahan untuk memanggil kelas di dalam kelas
       StrukturData2.Size sd2=new StrukturData2.Size();
       System.out.println(sd2.getSize());
     }
     //tambahan kelas static nested class (KELAS DI DALAM KELAS)
     static class Size{
       public int getSize(){
            return SIZE;
       }
     }
}
Hasilnya adalah:
TUGAS:
public class StrukturDataTugas{
//Ciptakan array
     private final static int SIZE=15; //Hilangkan staticnya mejadi:
     //private final int SIZE=15; (hasilnya Error)
     private static String NAMA[]={“1. Arief”,”2. Satejo”,”3. Muhammad”,”4. Kinady”,”5. Dika”,”6. Arman”,”7. Ari”,”8. Setyo”,”9. Dodik”,   “10. Jaka”,”11. Ira”,”12. Asad”,”13. Yandi”,”14. Adek”,”15. Dian”};
     private int[] larikBulat=new int[SIZE];
     public StrukturDataTugas(){
        //Isi array dengan nilai bulat urut naik
        for (int i=0; i
              larikBulat[i]=i;
        }
     }
     public void printGenap(){
        //cetak nilai dari indeks genap dari array
        System.out.println(“”);
        System.out.println(“Daftar Bilangan Genap dalam Array Bilangan”);
        System.out.println(“===========================================”);
        InnerIteratorGenap iterator=this.new InnerIteratorGenap();
        while (iterator.hasNext()){
              System.out.print(iterator.getNext() + ” “);
        }
        System.out.println();
     }
        public void printGanjil(){
              //cetak nilai dari indeks ganjil dari array
        System.out.println(“”);
        System.out.println(“Daftar Bilangan Ganjil dalam Array Bilangan”);
        System.out.println(“===========================================”);
              InnerIteratorGanjil iterator=this.new InnerIteratorGanjil();
              while (iterator.hasNext()){
                     System.out.print(iterator.getNext() + ” “);
              }
              System.out.println();
        }
public void printNama(){
        //cetak nilai dari indeks genap dari array
        InnerIteratorNama iterator=this.new InnerIteratorNama();
        System.out.println(“”);
        System.out.println(“Daftar nama-nama dengan nomor Ganjil”);
        System.out.println(“=======================================”);
        while (iterator.hasNext()){
              System.out.println(iterator.getNext() + ” “);
        }
        System.out.println();
     }
//inner class untuk implementasi pola Iterator
     private class InnerIteratorGenap{
        //Star mulai dari awal array
        private int lanjut=0;
        public boolean hasNext(){
              //cek apakah elemen sekaranga dalah elemen terakhir array
              return (lanjut<=SIZE-1);
        }
        public int getNext(){
              //ambil nilai dalam indeks genap dari array
              int hasil=larikBulat[lanjut];
              //teruska ke elemen indeks genap selanjutnya
              lanjut +=2;
              return hasil;
        }
     }
//Membuat Kelas InnerIteratorGanjil
     private class InnerIteratorGanjil{
        //Star mulai dari awal array
        private int lanjut=1;
        public boolean hasNext(){
              //cek apakah elemen sekarang adalah elemen terakhir array
              return (lanjut<=SIZE-1);
        }
        public int getNext(){
              //ambil nilai dalam indeks ganjil dari array
              int hasil=larikBulat[lanjut];
              //teruska ke elemen indeks ganjil selanjutnya
              lanjut +=2;
              return hasil;
        }
     }
//Membuat Kelas InnerIteratorString
     private class InnerIteratorString{
        //Star mulai dari awal array
        private int lanjut=1;
        public boolean hasNext(){
              //cek apakah elemen sekarang adalah elemen terakhir array
              return (lanjut<=SIZE-1);
        }
        public int getNext(){
              //ambil nilai dalam indeks genap dari array
              int hasil=larikBulat[lanjut];
              //teruska ke elemen indeks genap selanjutnya
              lanjut +=2;
              return hasil;
        }
     }
//inner class untuk implementasi pola Iterator untuk String
     private class InnerIteratorNama{
        //Star mulai dari awal array
        private int lanjut=0;
        public boolean hasNext(){
              //cek apakah elemen sekarang adalah elemen terakhir array
              return (lanjut<=SIZE-1);
        }
        public String getNext(){
              //ambil nilai dalam indeks genap dari array
              String hasil=NAMA[lanjut];
              //teruska ke elemen indeks genap selanjutnya
              lanjut +=2;
              return hasil;
        }
     }
//===================================================
     public static void main(String[]args){
        //isi array dengan nilai bulat urut naik
        //dan cetak nilai pada indeks genap
        StrukturDataTugas sd=new StrukturDataTugas();
        sd.printGenap();
        sd.printGanjil();
        sd.printNama();
        System.out.println(“”);
        System.out.println(“Banyaknya Data Array : “);
        System.out.println(“=======================================”);
        //tambahan untuk memanggil kelas di dalam kelas
        StrukturData2.Size sd2=new StrukturData2.Size();
        System.out.println(sd2.getSize());
     }
     //tambahan kelas static nested class (KELAS DI DALAM KELAS)
     static class Size{
        public int getSize(){
              return SIZE;
        }
     }
}
KESIMPULAN:
1.       Ketentuan dasar yang berlaku pada variabel, konstruktor dan method pada program di java berlaku pula pada inner class tersebut, yaitu:
a.       Variabel dan method pada kelas luar dapat diakses oleh kelas inner (nested class)
b.      Variabel dan method non static tidak dapat diakses oleh inner kelas static namun variabel dan method static dapat diakses oleh kelas non static.
2.       Dalam menciptakan objek sama seperti halnya dalam menciptakan objek pada kelas-kelas biasa.
Advertisements

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s