Mga Inner Class ng Java

Sa Java ang ilang mga klase ay maaaring maglaman ng iba pang mga klase sa loob ng mga ito. Ang ganitong mga klase ay tinatawag na mga nested na klase. Ang mga klase na tinukoy sa loob ng ibang mga klase ay karaniwang nahahati sa dalawang kategorya — static at non-static. Ang mga nested non-static na klase ay tinatawag na panloob. Ang mga nested class na idineklara na static ay tinatawag na static nested classes. Sa katunayan, walang kumplikado dito, kahit na ang terminolohiya ay mukhang malabo at kung minsan ay maaaring malito kahit isang propesyonal na developer ng software.

Nested at panloob na mga klase

Kaya lahat ng mga klase na matatagpuan sa loob ng ibang mga klase ay tinatawag na mga Nested na klase.

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

Ang mga Nested Class na hindi static ay tinatawag na Inner Classes , at ang mga static ay tinatawag na static Nested Classes . Java Inner Classes - 1

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

Kaya, lahat ng Inner Class ay Nested, ngunit hindi lahat Nested ay Inner. Ito ang mga pangunahing kahulugan. Ang mga panloob na klase ay isang uri ng mekanismo ng seguridad sa Java. Alam namin na ang isang ordinaryong klase ay hindi maaaring iugnay sa isang pribadong access modifier. Gayunpaman, kung ang aming klase ay miyembro ng ibang klase, kung gayon ang panloob na klase ay maaaring gawing pribado. Ginagamit din ang feature na ito para ma-access ang mga pribadong miyembro ng klase.

Halimbawa ng Inner Class

Kaya, subukan nating lumikha ng ilang klase, at sa loob nito — isa pang klase. Isipin ang ilang uri ng modular game console. Mayroong isang "kahon" mismo, at ang ilang mga module ay maaaring konektado dito. Halimbawa, isang controller ng laro, isang manibela, isang helmet ng VR, na, bilang panuntunan, ay hindi gumagana nang wala ang console mismo. Narito mayroon kaming klase ng GameConsole. Mayroon itong 2 field at 1 method — start() . Ang pagkakaiba sa pagitan ng GameCosole at ng klase na nakasanayan natin ay mayroon itong panloob na klase ng GameController .

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");
        }

    }

}

Sa puntong ito, maaaring nagtataka ka: bakit hindi gawing "hiwalay" ang mga klase? Hindi kinakailangan na gawin silang nested. Sa katunayan ito ay posible. Sa halip, ito ay tungkol sa tamang disenyo ng mga klase sa mga tuntunin ng kanilang paggamit. Ang mga panloob na klase ay nilikha upang i-highlight sa programa ang isang entity na hindi mapaghihiwalay na nauugnay sa isa pang entity. Ang isang controller o, halimbawa, isang VR helmet ay mga bahagi ng console. Oo, maaari silang bilhin nang hiwalay mula sa console, ngunit hindi magagamit kung wala ito. Kung ginawa naming magkahiwalay ang lahat ng klaseng ito sa mga pampublikong klase, maaaring magkaroon ang aming programa, halimbawa, ng sumusunod na code:

public class Main {

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

Ang mangyayari sa kasong ito ay hindi malinaw, dahil ang controller mismo ay hindi gumagana nang walang console. Gumawa kami ng object ng game console. Ginawa namin ang sub-object nito — ang controller ng laro. At ngayon ay maaari na tayong maglaro, pindutin lamang ang mga tamang key. Ang mga pamamaraan na kailangan natin ay tinatawag sa mga tamang bagay. Ang lahat ay simple at maginhawa. Sa halimbawang ito, ang pag-extract sa controller ng laro ay nagpapahusay sa encapsulation (tinatago namin ang mga detalye ng mga bahagi ng console sa loob ng kaukulang klase), at nagbibigay-daan para sa isang mas detalyadong abstraction. Ngunit kung tayo, halimbawa, ay gagawa ng isang programa na gayahin ang isang tindahan kung saan maaari kang hiwalay na bumili ng VR helmet o controller, ang halimbawang ito ay mabibigo. Doon ay mas mahusay na lumikha ng isang controller ng laro nang hiwalay. Kumuha tayo ng isa pang halimbawa. Nabanggit namin sa itaas na maaari naming gawing pribado ang inner class at tawagin pa rin ito mula sa outer class. Nasa ibaba ang isang halimbawa ng naturang mga klase.

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();
   }
}

Narito ang OuterClass ay ang panlabas na klase, ang InnerClass ay ang panloob na klase, ang display() ay ang pamamaraan sa loob kung saan tayo ay lumilikha ng isang bagay ng panloob na klase. Ngayon, magsulat tayo ng demo class na may pangunahing pamamaraan kung saan gagamitin natin ang display() na paraan.

public class OuterDemoMain {

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

           outer.display();
       }
}

Kung patakbuhin mo ang program na ito, makukuha mo ang sumusunod na resulta:

Nasa inner class kami...

Pag-uuri ng mga panloob na klase

Ang mga panloob na klase mismo o ang mga nested non-static na klase ay nabibilang sa tatlong grupo.

Inner class gaya ng dati. Isang hindi static na klase lamang sa loob ng isa pa tulad ng ipinakita namin sa itaas gamit ang halimbawa ng GameConsole at GameController .
Method-local Inner class ay isang klase sa loob ng isang method.
Anonymous Inner class.

Pamamaraan ng lokal na Inner class

Sa Java maaari kang magsulat ng isang klase sa loob ng isang pamamaraan at ito ay isang lokal na uri. Tulad ng mga lokal na variable, ang saklaw ng isang panloob na klase ay limitado sa loob ng isang pamamaraan. Ang isang pamamaraan-lokal na panloob na klase ay maaari lamang gawin sa loob ng pamamaraan kung saan tinukoy ang panloob na klase. Ipakita natin kung paano gamitin ang lokal na pamamaraan sa loob ng klase.

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();
   }
}

Ngayon kami ay magsusulat ng isang demo class na may pangunahing pamamaraan kung saan kami ay gagamit ng outer() na pamamaraan.

public class OuterDemoMain {


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

Ang output ay:

Narito mayroon kaming isang pamamaraan sa loob ng klase... at ito ay isang halaga mula sa OuterDemo2 class na myMethod

Anonymous na panloob na klase

Ang inner class na idineklara nang walang pangalan ng klase ay tinatawag na anonymous na inner class. Kapag nagdeklara kami ng anonymous na inner class, agad namin itong ginagawa. Karaniwan, ang mga ganitong klase ay ginagamit sa tuwing kailangan mong i-override ang isang klase o paraan ng interface.

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();
       }
   }

Ang output ay narito:

Narito mayroon kaming isang halimbawa ng isang hindi kilalang panloob na klase...

Anonymous Inner Class bilang Argumento

Maaari ka ring magpasa ng hindi kilalang panloob na klase bilang argumento sa pamamaraan. Narito ang isang halimbawa.

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!";
               }
           });
       }
}

Ang output ay narito:

Kamusta! halimbawa ng anonymous na inner class bilang argumento

Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course

Mga komento

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION