Kelas Dalam Java

Di Java, beberapa kelas dapat memuat kelas lain di dalamnya. Kelas-kelas seperti ini disebut kelas bersarang. Kelas yang didefinisikan dalam kelas lain umumnya terbagi dalam dua kategori — statis dan non-statis. Kelas non-statis yang bersarang disebut kelas dalam. Kelas bersarang yang dinyatakan statis disebut kelas bersarang statis. Sebenarnya, tidak ada yang rumit di sini, meskipun terminologinya terlihat agak kabur dan terkadang membingungkan bahkan pengembang perangkat lunak profesional.

Kelas bersarang dan dalam

Jadi semua kelas yang terletak di dalam kelas lain disebut kelas Bersarang.

class OuterClass {
    ...
    class NestedClass {
        ...
    }
}

Kelas Bersarang yang tidak statis disebut Kelas Dalam , dan Kelas Bersarang yang statis disebut Kelas Bersarang statis .

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

Jadi, semua Kelas Dalam Bersarang, tetapi tidak semua Kelas Bersarang adalah Kelas Dalam. Ini adalah definisi utama. Kelas dalam adalah semacam mekanisme keamanan di Java. Kita tahu bahwa kelas biasa tidak dapat dikaitkan dengan pengubah akses privat. Namun, jika kelas kita adalah anggota dari kelas lain, maka kelas dalam dapat dijadikan pribadi. Fitur ini juga digunakan untuk mengakses anggota kelas privat.

Contoh Kelas Dalam

Jadi, mari kita coba membuat beberapa kelas, dan di dalamnya — kelas lain. Bayangkan semacam konsol game modular. Ada “kotak” itu sendiri, dan modul tertentu dapat dihubungkan ke sana. Misalnya, pengontrol permainan, setir, helm VR, yang biasanya tidak berfungsi tanpa konsol itu sendiri. Di sini kita memiliki kelas GameConsole. Ini memiliki 2 bidang dan 1 metode — start() . Perbedaan antara GameCosole dan kelas yang biasa kita gunakan adalah ia memiliki kelas GameController internal .

public class GameConsole {
    private String model;
    private int weight;

    public void run() {
        System.out.println("Game console is on");
    }


    public class GameController {

        private String color;

        public void start() {
            System.out.println("start button is pressed");
        }

        public void x() {
            System.out.println("x button is pressed");
        }

        public void y() {
            System.out.println("y button is pressed");
        }
        public void a() {
            System.out.println("a button is pressed");
        }

        public void b() {
            System.out.println("b button is pressed");
        }
        public void mover() {
            System.out.println("mover button is pressed");
        }

    }

}

Pada titik ini, Anda mungkin bertanya-tanya: mengapa tidak membuat kelas-kelas ini "terpisah"? Tidak perlu membuat mereka bersarang. Memang itu mungkin. Sebaliknya, ini tentang desain kelas yang benar dalam hal penggunaannya. Kelas dalam dibuat untuk menyorot dalam program suatu entitas yang terkait erat dengan entitas lain. Pengontrol atau, misalnya, helm VR adalah komponen konsol. Ya, mereka dapat dibeli secara terpisah dari konsol, tetapi tidak dapat digunakan tanpanya. Jika kita membuat semua kelas ini menjadi kelas publik yang terpisah, program kita dapat memiliki, misalnya, kode berikut:

public class Main {

   public static void main(String[] args) {
       GameController controller = new GameController();
       controller.x();
   }
}

Apa yang terjadi dalam kasus ini tidak jelas, karena pengontrolnya sendiri tidak akan berfungsi tanpa konsol. Kami telah membuat objek konsol game. Kami membuat sub-objeknya — pengontrol permainan. Dan sekarang kita bisa bermain, cukup tekan tombol kanan. Metode yang kita perlukan dipanggil pada objek yang tepat. Semuanya sederhana dan nyaman. Dalam contoh ini, mengekstraksi pengontrol game akan meningkatkan enkapsulasi (kami menyembunyikan detail bagian konsol di dalam kelas yang sesuai), dan memungkinkan abstraksi yang lebih detail. Namun jika kita, misalnya, membuat program yang menyimulasikan toko tempat Anda dapat membeli helm atau pengontrol VR secara terpisah, contoh ini akan gagal. Di sana lebih baik membuat pengontrol game secara terpisah. Mari kita ambil contoh lain. Kami telah menyebutkan di atas bahwa kami dapat menjadikan kelas dalam menjadi pribadi dan tetap memanggilnya dari kelas luar. Di bawah ini adalah contoh kelas tersebut.

class OuterClass {

   // inner class
   private class InnerClass {
       public void print() {
           System.out.println("We are in the inner class...");
       }
   }

   // method of outer class. We are create an inner class from the method of outer one
   void display() {
       InnerClass inner = new InnerClass();
       inner.print();
   }
}

Di sini OuterClass adalah kelas luar, InnerClass adalah kelas dalam, display() adalah metode di mana kita membuat objek kelas dalam. Sekarang mari kita menulis kelas demo dengan metode utama dimana kita akan memanggil metode display() .

public class OuterDemoMain {

       public static void main(String args[]) {
           // create an object of the outer class
           OuterDemo outer = new OuterDemo();

           outer.display();
       }
}

Jika Anda menjalankan program ini, Anda akan mendapatkan hasil sebagai berikut:

Klasifikasi kelas dalam

Kelas dalam itu sendiri atau kelas non-statis bersarang terbagi dalam tiga kelompok.

• Kelas dalam apa adanya. Hanya satu kelas non-statis di dalam kelas lainnya seperti yang kami tunjukkan di atas dengan contoh GameConsole dan GameController .
• Metode-lokal Kelas dalam adalah kelas di dalam suatu metode.
• Kelas dalam Anonim.

Metode kelas dalam lokal

Di Java Anda dapat menulis kelas di dalam suatu metode dan itu adalah tipe lokal. Seperti variabel lokal, cakupan kelas dalam dibatasi dalam suatu metode. Kelas dalam metode-lokal hanya dapat dibuat dalam metode di mana kelas dalam ditentukan. Mari kita tunjukkan cara menggunakan metode lokal kelas dalam.

public class OuterDemo2 {

   //instance method of the outer class OuterDemo2
   void myMethod() {
       String str = "and it's a value from OuterDemo2 class' myMethod ";

       // method-local inner class
       class methodInnerDemo {
           public void print() {
               System.out.println("Here we've got a method inner class... " );
               System.out.println(str);

           }
       }

       // Access to the inner class
       methodInnerDemo inn = new methodInnerDemo();
       inn.print();
   }
}

Sekarang kita akan menulis kelas demo dengan metode utama di mana kita akan memanggil metode luar() .

public class OuterDemoMain {


   public static void main(String args[]) {
       OuterDemo2 outer = new OuterDemo2();
       outer.myMethod();
   }
}

Outputnya adalah:

Kelas dalam anonim

Kelas dalam yang dideklarasikan tanpa nama kelas disebut kelas dalam anonim. Saat kami mendeklarasikan kelas dalam anonim, kami segera membuat instance-nya. Biasanya, kelas seperti itu digunakan kapan pun Anda perlu mengganti kelas atau metode antarmuka.

abstract class OuterDemo3 {
   public abstract void method();

}
   class outerClass {

       public static void main(String args[]) {
           OuterDemo3 inner = new OuterDemo3() {
               public void method() {
                   System.out.println("Here we've got an example of an  anonymous inner class");
               }
           };
           inner.method();
       }
   }

Outputnya ada di sini:

Kelas Dalam Anonim sebagai Argumen

Anda juga dapat meneruskan kelas dalam anonim sebagai argumen untuk metode ini. Ini sebuah contoh.

interface OuterDemo4 {
       String hello();
   }

   class NewClass {
       // accepts the object of interface
       public void displayMessage(OuterDemo4 myMessage) {
           System.out.println(myMessage.hello());
           System.out.println("example of anonymous inner class as an argument");
       }

       public static void main(String args[]) {
           NewClass newClass = new NewClass();

           //here we pass an anonymous inner class as an argument
           newClass.displayMessage(new OuterDemo4() {
               public String hello() {
                   return "Hello!";
               }
           });
       }
}

Outputnya ada di sini: Untuk memperkuat apa yang Anda pelajari, kami sarankan Anda menonton video pelajaran dari Kursus Java kami