Inner Class

Inner Class merupakan sebuah class yang dideklarasikan di dalam class lain. Mirip dengan inheritence class inner akan mendapatkan akses terhadap class outernya atau class tempat inner class tersebut dideklarasikan termasuk atribute - atribute yang memiliki modifier private. Selain itu, dengan menggunakan inner class kita dapat menggunakan modifier private terhadap inner class yang mana hal ini tidak memungkinkan jika dilakukan pada outer class. Adapun untuk mendeklarasikan sebuah inner class dapat dilakukan dengan cukup sederhana yaitu seperti contoh berikut ini:

class induk{
    private int angka;
    public String Nama;

    private class anak{
        public String sekolah;
    }
}

Dapat dilihat pada contoh di atas kita mencoba mendeklarasikan inner class dengan nama anak di dalam class induk. Dengan demikian class anak dapat menggunakan seluruh atribute yang dimiliki oleh outer classnya. Namun, terdapat sedikir perbedaan mengenai cara penggunaan dan cara pendeklarasiannya. Untuk mendeklarasikan inner class non static maka kita perlu mendeklarasikannya melalui object dari outer classnya. Perhatikan cara berikut ini:

induk induk_1 = new induk();
induk.anak anak_1 = induk_1.new anak();

Kode di atas merupakan cara kita untuk mendeklarasikan object anak_1 dari inner class object induk_1. Lalu bagaimana jika kita ingin menggunakan value atribute outer di dalam inner class, perhatikan contoh berikut:

class anak extends induk{
        public String sekolah;
        public void show(){
            System.out.printf("Hello : %s",induk.this.Nama);
   }
}

Untuk menggunakan value dari atribute outer di dalam inner kita perlu memanggil class outernya terlebih dahulu dan diikuti dengan this kemudian nama dari atributenya karena inner class tidak memiliki atribute tetapi dapat menggunakan value dari atributenya yang mana ini berbeda dengan inheritence sehingga kita perlu membuat atribute inner class sendiri.

class anak {
        public void show(){
            System.out.printf("Hello : %s",induk.this.Nama);
        }
}

Selain cara pendeklarasian di atas kita juga dapat mendeklarasikan inner class di dalam sebuah method. Berikut contohnya:

class induk{
    private int angka;
    public String Nama;

       class anak {
        public void show(){

            System.out.printf("Hello : %s",induk.this.angka);
        }
    }
    public anak createanak()
    {
        anak anak_1 = new anak();
        return anak_1;
    }
}

public class innerclass {
    public static void main(String[] args) {
        induk induk_1 = new induk();
        induk.anak anak_1 =  induk_1.createanak();
        anak_1.show();
    }
}

Static Inner Class

Jika sebelumnya class bergantung pada object maka dengan menggunakan static inner class akan bergantung pada classnya. Maksud dari bergantung kepada class itu seperti apa? mari perhatikan contoh berikut:

class induk{
    private int angka;
    public String Nama;

    static class anak {
        public void show(){

            System.out.print("Hello");
        }
    }
}

public class innerclass {
    public static void main(String[] args) {
        induk induk_1 = new induk();
        induk.anak anak_1 = new induk.anak();
    }
}

Namun, dengan cara di atas semua atribute milik outer yang tidak static tidak dapat digunakan oleh inner classnya. Jika ingin digunakan maka perlu merubahnya menjadi static atribute terlebih dahulu.

Abstract Class

Pada pembahasan berikutnya kita akan membahas mengenai abstract class yaitu class yang bersifat abstrak. Dengan sifat abstrak tersebut, abstract class memiliki kemampuan untuk tidak dapat diakses selain melalui turunannya sehingga dengan begitu kita tidak dapat menggunakan atribute atau method yang dimiliki oleh class abstract secara langsung. Untuk mendeklarasikan class abstract cukup mudah, hanya dengan menambahkan keyword abstract di depan class maka class tersebut akan menjadi class abstract. Berikut cara kita mendeklarasikan abstract class:

abstract class induk{
    String nama,kelas;
    int usia;
}

class anak extends induk{
    anak(String Nama, String kelas, int usia){
        this.nama = Nama;
        this.kelas = kelas;
        this.usia = usia;
    }
}

Dengan kode di atas kita tidak dapat membuat object dari class induk tetapi dapat menggunakan atribute - atribute di class induk melalui object class anak. Tujuan dari abstract class ini sendiri adalah untuk membuat kerangka kerja terhadap class class turunannya.

Interface

Interface merupakan sebuah mekanisme untuk membuat aturan blue print yang mana memaksa sebuah class yang mengimplementasikan interface untuk memiliki seluruh method yang dimuat oleh interface. Interface sendiri berisi abstract method yang tidak memiliki body atau isi methodnya. Adapun untuk membuat interface sangatlah mudah. Perhatikan contoh berikut:

interface Terbang{
    void terbang();
}

interface Berenang{
    void berenang();
}

class Burung implements Terbang,Berenang{
    String Nama;
    Burung(String Nama){
        this.Nama = Nama;
    }

    @Override
    public void terbang() {
        System.out.printf("%s terbang\n",this.Nama);
    }

    @Override
    public void berenang() {
        System.out.printf("%s berenang\n",this.Nama);
    }
}


public class innerclass {
    public static void main(String[] args) {
        Burung burung_1 = new Burung("pipit");
        burung_1.berenang();
        burung_1.terbang();
    }
}

Pada contoh di atas terdapat sebuah class dengan nama Burung yang mengimplementasikan interface terbang dan berenang sehingga dengan begitu class Burung wajib mengimplementasikan atau memiliki method yang terdapat di dalam kedua interface tersebut. Jika tidak maka program akan error.