Mga hindi kilalang klase sa Java

Kamusta! Sa aralin ngayon ay patuloy nating titingnan ang paksa ng mga nested classes. Ito na ang turn ng huling grupo - anonymous na mga panloob na klase sa Java. Bumalik tayo sa ating diagram: Tulad ng mga lokal na klase na pinag-usapan natin sa huling lecture, ang mga anonymous na klase ay isang subset ng mga panloob na klase. Mayroon din silang ilang pagkakatulad at pagkakaiba sa pagitan nila. Ngunit una, alamin natin ito: bakit sila talaga tinatawag na "anonymous"? Upang gawin ito, tingnan natin ang isang simpleng halimbawa. Isipin na mayroon tayong pangunahing programa na patuloy na tumatakbo at gumagawa ng isang bagay. Nais naming lumikha ng isang sistema ng pagsubaybay para sa programang ito na binubuo ng ilang mga module. Ang isang module ay susubaybayan ang mga pangkalahatang tagapagpahiwatig ng pagganap at panatilihin ang isang log, ang pangalawa ay magtatala at mag-log ng mga error sa log ng error, ang pangatlo ay susubaybayan ang kahina-hinalang aktibidad: halimbawa, hindi awtorisadong mga pagtatangka sa pag-access at iba pang mga bagay na nauugnay sa seguridad. Dahil ang lahat ng tatlong mga module ay dapat magsimula lamang sa simula ng programa at tumakbo sa background, magandang ideya na lumikha ng isang karaniwang interface para sa kanila:

public interface MonitoringSystem {

   public void startMonitoring();
}

Ipapatupad ito ng 3 partikular na klase:

public class GeneralIndicatorsMonitoringModule implements MonitoringSystem {

@Override
   public void startMonitoring() {
       System.out.println("Monitoring of general indicators has started!");
   }
}


public class ErrorMonitoringModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Bug Tracking Monitoring Started!");
   }
}


public class SecurityModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Security monitoring started!");
   }
}

Mukhang maayos na ang lahat. Mayroon kaming medyo malinaw na sistema ng ilang mga module. Ang bawat isa sa kanila ay may sariling pag-uugali. Kung kailangan namin ng mga bagong module, maaari naming idagdag ang mga ito, dahil mayroon kaming isang interface na medyo madaling ipatupad. Ngunit isipin natin kung paano gagana ang ating monitoring system. Sa esensya, dapat lang tayong lumikha ng 3 bagay - GeneralIndicatorsMonitoringModule, ErrorMonitoringModule, SecurityModule- at tumawag ng paraan startMonitoring()sa bawat isa sa kanila. Iyon ay, ang kailangan mo lang gawin ay lumikha ng 3 bagay at tumawag ng 1 paraan sa kanila.

public class Main {

   public static void main(String[] args) {

       GeneralIndicatorsMonitoringModule generalModule = new GeneralIndicatorsMonitoringModule();
       ErrorMonitoringModule errorModule = new ErrorMonitoringModule();
       SecurityModule securityModule = new SecurityModule();

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

Output ng console:

Мониторинг общих показателей стартовал!
Мониторинг отслеживания ошибок стартовал!
Мониторинг безопасности стартовал!

At para sa isang maliit na trabaho, sumulat kami ng isang buong sistema: 3 klase at isang interface! At lahat ng ito para sa kapakanan ng 6 na linya ng code. Sa kabilang banda, ano ang aming mga pagpipilian? Oo, hindi masyadong cool na isinulat namin ang mga "disposable" na klase. Ngunit paano natin ito maaayos? Dito tinutulungan kami ng mga hindi kilalang panloob na klase ! Narito kung ano ang hitsura nila sa aming kaso:

public class Main {

   public static void main(String[] args) {

       MonitoringSystem generalModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Monitoring of general indicators has started!");
           }
       };



           MonitoringSystem errorModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Bug Tracking Monitoring Started!");
           }
       };

       MonitoringSystem securityModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Security monitoring started!");
           }
       };

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

Alamin natin kung ano ang nangyayari dito! Mukhang gumagawa kami ng interface object:

MonitoringSystem generalModule = new MonitoringSystem() {

@Override
   public void startMonitoring() {
       System.out.println("Monitoring of general indicators has started!");
   }
};

Ngunit alam namin sa loob ng mahabang panahon na imposibleng lumikha ng mga bagay sa interface! Tama, imposible. Sa katunayan, hindi namin ginagawa iyon. Sa sandaling sumulat tayo:

MonitoringSystem generalModule = new MonitoringSystem() {

};

Sa loob ng Java machine nangyayari ang sumusunod:

1. Isang hindi pinangalanang Java class ang nilikha na nagpapatupad ng MonitoringSystem.
2. Ang compiler, na nakikita ang ganitong klase, ay nangangailangan sa iyo na ipatupad ang lahat ng mga pamamaraan ng interface MonitoringSystem(ginawa namin ito ng 3 beses).
3. Isang bagay ng klase na ito ay nilikha. Bigyang-pansin ang code:

MonitoringSystem generalModule = new MonitoringSystem() {

};

May semicolon sa dulo! She's standing there for a reason. Sabay-sabay kaming nagdedeklara ng isang klase (sa pamamagitan ng mga kulot na braces) at nililikha ang object nito gamit (); ang bawat isa sa aming tatlong object ay nag-override ng isang paraan startMonitoring()sa sarili nitong paraan. Sa dulo ay tinatawag lang namin ang pamamaraang ito sa bawat isa sa kanila:

generalModule.startMonitoring();
errorModule.startMonitoring();
securityModule.startMonitoring();

Output ng console:

Мониторинг общих показателей стартовал!
Мониторинг отслеживания ошибок стартовал!
Мониторинг безопасности стартовал!

Iyon lang! Nakumpleto na namin ang aming gawain: nakagawa kami ng tatlong bagay MonitoringSystem, muling tinukoy ito sa tatlong magkakaibang paraan, at tinawag itong tatlong beses. Ang lahat ng tatlong mga module ay matagumpay na nailunsad at gumagana. Kasabay nito, ang istraktura ng aming programa ay naging mas simple! GeneralIndicatorsMonitoringModulePagkatapos ng lahat , maaari ErrorMonitoringModulena ngayong alisin ang mga klase SecurityModulesa programa nang buo! Hindi lang namin kailangan ang mga ito - nagtagumpay kami nang wala sila. Kung ang bawat isa sa aming mga anonymous na klase ng module ay nangangailangan ng ilang iba't ibang pag-uugali, ang sarili nitong mga partikular na pamamaraan na wala sa iba, madali naming maidaragdag ang mga ito:

MonitoringSystem generalModule = new MonitoringSystem() {

   @Override
   public void startMonitoring() {
       System.out.println("Monitoring of general indicators has started!");
   }

   public void someSpecificMethod() {

       System.out.println("Specific method for first module only");
   }
};

Ang dokumentasyon ng Oracle ay may magandang rekomendasyon : "Gumamit ng mga hindi kilalang klase kung kailangan mo ng lokal na klase para sa isang beses na paggamit." Ang hindi kilalang klase ay isang ganap na panloob na klase. Samakatuwid, mayroon itong access sa mga variable na panlabas na klase, kabilang ang mga static at pribado:

public class Main {

   private static int currentErrorsCount = 23;

   public static void main(String[] args) {

       MonitoringSystem errorModule = new MonitoringSystem() {

           @Override
           public void startMonitoring() {
               System.out.println("Bug Tracking Monitoring Started!");
           }

           public int getCurrentErrorsCount() {

               return currentErrorsCount;
           }
       };
   }
}

Mayroon silang isang bagay na karaniwan sa mga lokal na klase: makikita lamang sila sa loob ng pamamaraan kung saan tinukoy ang mga ito. Sa halimbawa sa itaas, ang anumang pagtatangka na i-access ang bagay errorModulesa labas ng pamamaraan main()ay mabibigo. At isa pang mahalagang limitasyon na minana ng mga anonymous na klase mula sa kanilang "mga ninuno" - mga panloob na klase: hindi maaaring maglaman ng mga static na variable at pamamaraan ang isang anonymous na klase . Kung susubukan naming gawin ang pamamaraan getCurrentErrorsCount()mula sa halimbawa sa itaas na static, ang compiler ay magtapon ng isang error:

//error! Inner classes cannot have static declarations
public static int getCurrentErrorsCount() {

   return currentErrorsCount;
}

Nakukuha namin ang parehong resulta kung susubukan naming magdeklara ng isang static na variable:

MonitoringSystem errorModule = new MonitoringSystem() {

   //error! Inner classes cannot have static declarations!
   static int staticInt = 10;

   @Override
   public void startMonitoring() {
       System.out.println("Bug Tracking Monitoring Started!");
   }

};

Sa wakas, maaari kong irekomenda sa iyo ang isang mahusay na video sa paksa ng mga hindi kilalang klase, kung saan ang paksang ito ay ipinaliwanag nang simple at malinaw hangga't maaari :) At ang ating aralin ngayon ay natapos na! At bagama't natalakay na namin ang huling pangkat ng mga nested na klase, hindi pa kami tapos sa paksang ito. Ano ang susunod nating pag-aaralan tungkol sa mga nested classes? Siguradong malalaman mo agad! :)