Kelas Dalaman Java

Di Java sesetengah kelas boleh mengandungi kelas lain di dalamnya. Kelas sedemikian dipanggil kelas bersarang. Kelas yang ditakrifkan dalam kelas lain biasanya terbahagi kepada dua kategori — statik dan bukan statik. Kelas bukan statik bersarang dipanggil dalam. Kelas bersarang yang diisytiharkan statik dipanggil kelas bersarang statik. Sebenarnya, tidak ada yang rumit di sini, walaupun istilahnya kelihatan agak kabur dan kadangkala boleh mengelirukan walaupun pembangun perisian profesional.

Kelas bersarang dan dalaman

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

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

Kelas Bersarang yang tidak statik dipanggil Kelas Dalaman dan kelas statik dipanggil Kelas Bersarang statik . Kelas Dalaman Java - 1

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

Oleh itu, semua Kelas Dalaman adalah Bersarang, tetapi tidak semua Bersarang adalah Dalaman. Ini adalah definisi utama. Kelas dalaman adalah sejenis mekanisme keselamatan di Jawa. Kami tahu bahawa kelas biasa tidak boleh dikaitkan dengan pengubah akses peribadi. Walau bagaimanapun, jika kelas kita adalah ahli kelas lain, maka kelas dalaman boleh dijadikan peribadi. Ciri ini juga digunakan untuk mengakses ahli kelas persendirian.

Contoh Kelas Dalaman

Jadi, mari cuba buat beberapa kelas, dan di dalamnya — kelas lain. Bayangkan beberapa jenis konsol permainan modular. Terdapat "kotak" itu sendiri, dan modul tertentu boleh disambungkan kepadanya. Sebagai contoh, pengawal permainan, stereng, topi keledar VR, yang, sebagai peraturan, tidak berfungsi tanpa konsol itu sendiri. Di sini kami mempunyai kelas GameConsole. Ia mempunyai 2 medan dan 1 kaedah — start() . Perbezaan antara GameCosole dan kelas yang kita biasa gunakan ialah ia mempunyai kelas GameController dalaman .

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 ketika ini, anda mungkin tertanya-tanya: mengapa tidak menjadikan kelas ini "diasingkan"? Ia tidak perlu membuat mereka bersarang. Memang boleh. Sebaliknya, ini adalah mengenai reka bentuk kelas yang betul dari segi penggunaannya. Kelas dalaman dicipta untuk menyerlahkan dalam program entiti yang berkait rapat dengan entiti lain. Pengawal atau, sebagai contoh, topi keledar VR adalah komponen konsol. Ya, mereka boleh dibeli secara berasingan daripada konsol, tetapi tidak boleh digunakan tanpanya. Jika kami membuat semua kelas ini memisahkan kelas awam, program kami mungkin mempunyai, sebagai contoh, kod berikut:

public class Main {

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

Apa yang berlaku dalam kes ini tidak jelas, kerana pengawal itu sendiri tidak berfungsi tanpa konsol. Kami telah mencipta objek konsol permainan. Kami mencipta sub-objeknya — pengawal permainan. Dan sekarang kita boleh bermain, hanya tekan kekunci yang betul. Kaedah yang kita perlukan dipanggil pada objek yang betul. Semuanya mudah dan selesa. Dalam contoh ini, mengekstrak pengawal permainan meningkatkan enkapsulasi (kami menyembunyikan butiran bahagian konsol di dalam kelas yang sepadan), dan membolehkan abstraksi yang lebih terperinci. Tetapi jika kita, sebagai contoh, mencipta program yang menyerupai kedai di mana anda boleh membeli topi keledar atau pengawal VR secara berasingan, contoh ini akan gagal. Di sana adalah lebih baik untuk mencipta pengawal permainan secara berasingan. Mari kita ambil contoh lain. Kami menyebut di atas bahawa kami boleh menjadikan kelas dalaman peribadi dan masih memanggilnya dari kelas luar. Di bawah ialah contoh kelas sedemikian.

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 ialah kelas luar, InnerClass ialah kelas dalam, display() ialah kaedah di dalamnya kita mencipta objek kelas dalam. Sekarang mari kita tulis kelas demo dengan kaedah utama di mana kita akan menggunakan kaedah paparan() .

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 mendapat hasil berikut:

Kami berada di kelas dalaman...

Klasifikasi kelas dalaman

Kelas dalaman itu sendiri atau kelas bukan statik bersarang dibahagikan kepada tiga kumpulan.

Kelas dalaman sebagaimana adanya. Hanya satu kelas bukan statik di dalam kelas yang lain seperti yang kami tunjukkan di atas dengan contoh GameConsole dan GameController .
Method-local Inner class ialah kelas di dalam kaedah.
Kelas Dalaman Tanpa Nama.

Kaedah kelas dalaman tempatan

Di Java anda boleh menulis kelas di dalam kaedah dan ia adalah jenis tempatan. Seperti pembolehubah tempatan, skop kelas dalaman adalah terhad dalam kaedah. Kelas dalam kaedah-tempatan hanya boleh dibuat dalam kaedah di mana kelas dalam ditakrifkan. Mari kita tunjukkan cara menggunakan kelas dalaman kaedah tempatan.

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 kaedah utama di mana kita akan menggunakan kaedah outer() .

public class OuterDemoMain {


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

Outputnya ialah:

Di sini kita mempunyai kelas dalam kaedah... dan ia adalah nilai daripada myMethod kelas OuterDemo2

Kelas dalaman tanpa nama

Kelas dalam yang diisytiharkan tanpa nama kelas dipanggil kelas dalam tanpa nama. Apabila kami mengisytiharkan kelas dalaman tanpa nama, kami segera mengisytiharkannya. Biasanya, kelas sedemikian digunakan apabila anda perlu mengatasi kelas atau kaedah antara muka.

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:

Di sini kita mempunyai contoh kelas dalaman tanpa nama...

Kelas Dalaman Tanpa Nama sebagai Hujah

Anda juga boleh lulus kelas dalaman tanpa nama sebagai hujah kepada kaedah tersebut. Berikut adalah 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:

helo! contoh kelas dalaman tanpa nama sebagai hujah

Untuk mengukuhkan perkara yang anda pelajari, kami cadangkan anda menonton pelajaran video daripada Kursus Java kami