JavaRush /Java Blog /Random-TL /10 Mga Tala sa Static Modifier sa Java

10 Mga Tala sa Static Modifier sa Java

Nai-publish sa grupo
Ang static na modifier sa Java ay direktang nauugnay sa klase. Kung ang field ay static, kung gayon ito ay kabilang sa klase, kung ang pamamaraan ay static, ito ay pareho: ito ay kabilang sa klase. Batay dito, maaari mong ma-access ang isang static na pamamaraan o field gamit ang pangalan ng klase. Halimbawa, kung static ang field ng count sa Counter class, maaari mong i-access ang variable gamit ang query tulad ng: Counter.count. 10 Mga Tala sa Static Modifier sa Java - 1Bago tayo magsimula sa mga tala, tandaan natin (at marahil ay alamin) kung ano ang static at kung ano ang maaaring maging static sa Java. Ang static ay isang modifier na inilapat sa isang field, block, method, o inner class. Ang modifier na ito ay nagpapahiwatig na ang paksa ay nakatali sa kasalukuyang klase.

Mga static na field

Kapag tinukoy namin ang isang variable sa antas ng klase, ipinapahiwatig namin na ang halaga ay kabilang sa isang klase. Kung hindi mo gagawin ito, ang halaga ng variable ay iuugnay sa isang bagay na nilikha gamit ang klase na ito. Ano ang ibig sabihin nito? 10 Mga Tala sa Static Modifier sa Java - 2At ang katotohanan ay kung ang variable ay hindi static, kung gayon ang bawat bagong object ng klase na ito ay magkakaroon ng sarili nitong halaga ng variable na ito, sa pamamagitan ng pagbabago kung saan binago namin ito ng eksklusibo sa isang object: Halimbawa, mayroon kaming klase ng Kotse na may hindi -static na variable:
public class Car {
  int km;
}
Pagkatapos sa pangunahing:
Car orangeCar = new Car();
orangeCar.km = 100;

Car blueCar = new Car();
blueCar.km = 85;

System.out.println("Orange car - " + orangeCar.km);
System.out.println("Blue car - " + blueCar.km);
Ang output na nakukuha namin ay:

Orange car - 100
Blue car - 85
Tulad ng nakikita mo, ang bawat bagay ay may sariling variable, ang pagbabago nito ay nangyayari lamang para sa bagay na ito. Well, kung mayroon tayong static na variable, ang global value na ito ay pareho para sa lahat: Ngayon ay mayroon na tayong Kotse na may static na variable:
public class Car {
  static int km;
}
Pagkatapos ang parehong code sa main ay maglalabas sa console:

Orange car - 85
Blue car - 85
Pagkatapos ng lahat, mayroon tayong isang variable para sa ating lahat, at sa tuwing babaguhin natin ito. Ang mga static na variable ay karaniwang ina-access hindi sa pamamagitan ng isang object reference - orangeCar.km, ngunit sa pamamagitan ng pangalan ng klase - Car.km

Static block

Mayroong dalawang mga bloke ng pagsisimula - regular at static. Ang block ay inilaan upang simulan ang mga panloob na variable. Kung ang bloke ay normal, kung gayon ang mga panloob na variable ng bagay ay sinisimulan dito, ngunit kung ito ay static, ang mga static na variable (iyon ay, mga variable ng klase) ay itinalaga sa kanila. Halimbawa ng isang klase na may static na initialization block:
public class Car {
  static int km;

  static {
     km = 150;
  }
}

Static na pamamaraan

Ang mga static na pamamaraan ay naiiba sa mga regular na pamamaraan dahil ang mga ito ay nakatali din sa isang klase sa halip na isang bagay. Ang isang mahalagang katangian ng isang static na pamamaraan ay ang maaari lamang nitong ma-access ang mga static na variable/pamamaraan. Bilang halimbawa, tingnan natin ang isang klase na magiging isang uri ng counter na sumusubaybay sa mga method call:
public class Counter {
  static int count;

  public static void invokeCounter() {
     count++;
     System.out.println("Current counter value - " + count);
  }
}
Tawagan natin ito sa pangunahing:
Counter.invokeCounter();
Counter.invokeCounter();
Counter.invokeCounter();
At nakukuha namin ang output sa console:

Текущее meaning счётчика - 1
Текущее meaning счётчика - 2
Текущее meaning счётчика - 3

Static na klase sa Java

Tanging isang panloob na klase ang maaaring maging isang static na klase. Muli, ang klase na ito ay nakatali sa panlabas na klase, at kung ang panlabas ay minana ng ibang klase, kung gayon ang isang ito ay hindi mamanahin. Bukod dito, ang klase na ito ay maaaring mamana, tulad ng maaari itong mamana mula sa anumang iba pang klase at magpatupad ng isang interface. Sa esensya, ang isang static na nested class ay hindi naiiba sa anumang iba pang panloob na klase, maliban na ang object nito ay hindi naglalaman ng isang reference sa outer class object na lumikha nito. Gayunpaman, ginagawa nitong halos kapareho ang isang static na klase sa isang regular na hindi nested, dahil ang pagkakaiba lang ay nakabalot ito sa ibang klase. Sa ilang mga kaso, ito ay isang kalamangan para sa amin, dahil mula dito mayroon kaming access sa mga pribadong static na variable ng panlabas na klase. Halimbawa ng isang nested static na klase:
public class Vehicle {

  public static class Car {
     public int km;
  }
}
Paglikha ng isang instance ng klase na ito at pagtatakda ng halaga ng panloob na variable:
Vehicle.Car car = new Vehicle.Car();
car.km = 90;
Upang gumamit ng mga static na pamamaraan/variable/klase, hindi namin kailangang gumawa ng object ng klase na iyon. Siyempre, dapat isaalang-alang ang mga access modifier. Halimbawa, ang mga field privateay maa-access lamang sa loob ng klase kung saan idineklara ang mga ito. protectedAvailable ang mga field sa lahat ng klase sa loob ng package ( package ), gayundin sa lahat ng nagmana na klase sa labas ng package. Para sa higit pang mga detalye, tingnan ang artikulong " pribado vs protektado kumpara sa publiko ". Ipagpalagay na mayroong isang static na pamamaraan increment()sa klase Counterna ang gawain ay dagdagan ang counter count. Upang tawagan ang paraang ito, maaari kang gumamit ng invocation ng form Counter.increment(). Hindi na kailangang mag-instantiate ng isang klase Counterupang ma-access ang isang static na field o pamamaraan. Ito ang pangunahing pagkakaiba sa pagitan ng static at NON-static na mga bagay (mga miyembro ng klase). Paalalahanan ko kayong muli na ang mga static na miyembro ng klase ay direktang nabibilang sa klase, hindi sa instance nito. Iyon ay, ang halaga ng isang static na variable countay magiging pareho para sa lahat ng mga bagay ng uri Counter. Sa ibang pagkakataon sa artikulong ito, titingnan natin ang mga pangunahing aspeto ng paggamit ng static na modifier sa Java, pati na rin ang ilang feature na makakatulong sa iyong maunawaan ang mga pangunahing konsepto ng programming.

Ano ang dapat malaman ng bawat programmer tungkol sa Static modifier sa Java

Sa seksyong ito, titingnan natin ang mga pangunahing kaalaman sa paggamit ng mga static na pamamaraan, field, at klase. Magsimula tayo sa mga variable.
  1. Hindi mo maa-access ang mga hindi static na miyembro ng isang klase sa loob ng isang static na konteksto, tulad ng isang paraan o block. Ang pag-compile ng code sa ibaba ay magreresulta sa isang error:

    public class Counter{
    private int count;
    public static void main(String args[]){
       System.out.println(count); //compile time error
    }}

    Ito ay isa sa mga pinakakaraniwang pagkakamali na ginawa ng mga programmer ng Java, lalo na ang mga baguhan. Dahil ang pamamaraan mainay static, ngunit ang variable countay hindi, sa kasong ito ang pamamaraan printlnsa loob ng pamamaraan mainay magtapon ng "Compile time error".

  2. В отличие от локальных переменных, статические поля и методы НЕ потокобезопасны (Thread-safe) в Java. На практике это одна из наиболее частых причин возникновения проблем связанных с безопасностью мультипоточного программирования. Учитывая что каждый экземпляр класса имеет одну и ту же копию статической переменной, то такая переменная нуждается в защите — «залочивании» классом. Поэтому при использовании статических переменных, убедитесь, что они должным образом синхронизированы (synchronized), во избежание проблем, например таких How «состояние гонки» (race condition).

  3. Статические методы имеют преимущество в применении, т.к. отсутствует необходимость каждый раз создавать новый an object для доступа к таким методам. Статический метод можно вызвать, используя тип класса, в котором эти методы описаны. Именно поэтому, подобные методы How нельзя лучше подходят в качестве методов-фабрик (factory), и методов-утorт (utility). Класс java.lang.Math — замечательный пример, в котором почти все методы статичны, по этой же причине классы-утorты в Java финализированы (final).

  4. Другим важным моментом является то, что вы НЕ можете переопределять (Override) статические методы. Если вы объявите такой же метод в классе-наследнике (subclass), т.е. метод с таким же именем и сигнатурой, вы лишь «спрячете» метод суперкласса (superclass) instead of переопределения. Это явление известно How сокрытие методов (hiding methods). Это означает, что при обращении к статическому методу, который объявлен How в родительском, так и в дочернем классе, во время компиляции всегда будет вызван метод исходя из типа переменной. В отличие от переопределения, такие методы не будут выполнены во время работы программы. Рассмотрим пример:

    class Vehicle{
         public static void  kmToMiles(int km){
              System.out.println("Inside parent class/static method");
         } }
    
    class Car extends Vehicle{
         public static void  kmToMiles(int km){
              System.out.println("Inside child class/static method ");
         } }
    
    public class Demo{
       public static void main(String args[]){
          Vehicle v = new Car();
           v.kmToMiles(10);
      }}

    Вывод в консоль:

    Внутри родительского класса/статического метода

    Код наглядно демонстрирует: несмотря на то, что an object имеет тип Car, вызван статический метод из класса Vehicle, т.к. произошло обращение к методу во время компиляции. И заметьте, ошибки во время компиляции не возникло!

  5. Объявить статическим также можно и класс, за исключением классов верхнего уровня. Такие классы известны How «вложенные статические классы» (nested static class). Они бывают полезными для представления улучшенных связей. Яркий пример вложенного статического класса — HashMap.Entry, который предоставляет структуру данных внутри HashMap. Стоит заметить, также How и любой другой внутренний класс, вложенные классы находятся в отдельном файле .class. Таким образом, если вы объявor пять вложенных классов в вашем главном классе, у вас будет 6 файлов с расширением .class. Ещё одним примером использования является объявление собственного компаратора (Comparator), например компаратор по возрасту (AgeComparator) в классе сотрудники (Employee).

  6. Модификатор static также может быть объявлен в статичном блоке, более известным How «Статический блок инициализации» (Static initializer block), который будет выполнен во время загрузки класса. Если вы не объявите такой блок, то Java соберёт все статические поля в один список и выполнит его во время загрузки класса. Однако, статичный блок НЕ может пробросить перехваченные исключения, но может выбросить не перехваченные. В таком случае возникнет «Exception Initializer Error». На практике, любое исключение возникшее во время выполнения и инициализации статических полей, будет завёрнуто Java в эту ошибку. Это также самая частая причина ошибки «No Class Def Found Error», т.к. класс не находился в памяти во время обращения к нему.

  7. Полезно знать, что статические методы связываются во время компиляции, в отличие от связывания виртуальных or не статических методов, которые связываются во время исполнения на реальном an objectе. Следовательно, статические методы не могут быть переопределены в Java, т.к. полиморфизм во время выполнения не распространяется на них. Это важное ограничение, которое необходимо учитывать, объявляя метод статическим. В этом есть смысл, только тогда, когда нет возможности or необходимости переопределения такого метода классами-наследниками. Методы-фабрики и методы-утorты хорошие образцы применения модификатора static. Джошуа Блох выделил несколько преимуществ использования статичного метода-фабрики перед конструктором, в книге «Effective Java», которая является обязательной для прочтения каждым программистом данного языка.

  8. Важным свойством статического блока является инициализация. Статические поля or переменные инициализируются после загрузки класса в память. Порядок инициализации сверху вниз, в том же порядке, в Howом они описаны в исходном файле Java класса. Поскольку статические поля инициализируются на потокобезопасный манер, это свойство также используется для реализации паттерна Singleton. Если вы не используется список Enum How Singleton, по тем or иным причинам, то для вас есть хорошая альтернатива. Но в таком случае необходимо учесть, что это не «ленивая» инициализация. Это означает, что статическое поле будет проинициализировано ещё ДО того How кто-нибудь об этом «попросит». Если an object ресурсоёмкий or редко используется, то инициализация его в статическом блоке сыграет не в вашу пользу.

  9. Sa panahon ng serialization, tulad ng transientmga variable, hindi serialized ang mga static na field. Sa katunayan, kung nagse-save ka ng anumang data sa isang static na field, pagkatapos ay pagkatapos ng deserialization ang bagong object ay maglalaman ng pangunahing (default) na halaga nito, halimbawa, kung ang static na field ay isang variable ng uri int, ang halaga nito pagkatapos ng deserialization ay magiging zero, kung ang uri floatay 0.0, kung uri Objectnull. Sa totoo lang, isa ito sa mga madalas itanong tungkol sa serialization sa mga panayam sa Java. Huwag iimbak ang pinakamahalagang data tungkol sa isang bagay sa isang static na field!

  10. At sa wakas, pag-usapan natin ang tungkol sa static import. Ang modifier na ito ay magkapareho sa karaniwang operator import, ngunit hindi katulad nito, pinapayagan ka nitong mag-import ng isa o lahat ng static na miyembro ng isang klase. Kapag nag-import ng mga static na pamamaraan, maa-access ang mga ito na parang tinukoy sa parehong klase, katulad din kapag nag-import ng mga field, maa-access natin ang mga ito nang hindi tinukoy ang pangalan ng klase. Ang tampok na ito ay ipinakilala sa bersyon ng Java 1.5, at kapag ginamit nang maayos, nagpapabuti sa pagiging madaling mabasa ng code. Ang konstruksiyon na ito ay madalas na matatagpuan sa mga pagsubok sa JUnit , dahil Halos lahat ng mga developer ng pagsubok ay gumagamit static importng mga paraan ng paggiit, halimbawa, assertEquals()at ang kanilang mga overload na duplicate. Kung walang malinaw, maligayang pagdating para sa karagdagang impormasyon .

Iyon lang. Dapat malaman ng bawat programmer ang lahat ng mga punto sa itaas tungkol sa static na modifier sa Java . Sinasaklaw ng artikulong ito ang pangunahing impormasyon tungkol sa mga static na variable, field, pamamaraan, initialization block at import. Kabilang ang ilang mahahalagang katangian, ang kaalaman kung saan ay kritikal kapag nagsusulat at umunawa ng mga programa sa Java. Umaasa ako na ang bawat developer ay maperpekto ang kanilang mga kasanayan sa paggamit ng mga static na konsepto dahil... Napakahalaga nito para sa seryosong programming."
Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION