Pangwakas, Mga Constant at Hindi Nababago sa Java

Kamusta! Ang salitang "modifier" ay pamilyar na sa iyo. Sa pinakamababa, nakatagpo ka ng mga modifier ng access (pampubliko, pribado) at ang static na modifier. Ngayon ay pag-uusapan natin ang tungkol sa espesyal na panghuling modifier . Masasabing "semento" ang mga lugar ng ating programa kung saan kailangan natin ng pare-pareho, hindi malabo, hindi nagbabagong pag-uugali. Maaari itong magamit sa tatlong bahagi ng aming programa: mga klase, pamamaraan at mga variable. Isa-isahin natin sila. Kung ang isang deklarasyon ng klase ay naglalaman ng panghuling modifier , nangangahulugan ito na hindi ka maaaring magmana mula sa klase na ito. Sa nakaraang mga lektura, nakakita kami ng isang simpleng halimbawa ng pamana: mayroon kaming klase ng magulang Animal, at dalawang klase ng bata - CatatDog

public class Animal {
}

public class Cat extends Animal {
   //..поля и методы класса Cat
}

public class Dog extends Animal {

   //..поля и методы класса Dog
}

Gayunpaman, kung tutukuyin namin Animalang isang modifier para sa isang klase, ang mga klase ay hindi rin finalmagagawang magmana mula dito . CatDog

public final class Animal {

}

public class Cat extends Animal {

   //ошибка! Cannot inherit from final Animal
}

Ang compiler ay agad na gumagawa ng isang error. Mayroong maraming mga -class na ipinatupad na sa Java final. Ang pinakasikat sa mga palagi mong ginagamit ay String. Bilang karagdagan, kung ang isang klase ay idineklara bilang final, ang lahat ng mga pamamaraan nito ay magiging final. Ano ang ibig sabihin nito? Kung may tinukoy na modifier para sa isang paraan final, hindi ma-override ang paraang ito. Halimbawa, mayroon kaming isang klase Animalna tumutukoy sa isang pamamaraan voice(). Gayunpaman, ang mga aso at pusa ay malinaw na "nag-uusap" nang naiiba. Samakatuwid, sa bawat isa sa mga klase - Catat Dog- gagawa kami ng isang pamamaraan voice(), ngunit ipapatupad namin ito nang iba.

public class Animal {

   public void voice() {
       System.out.println("Voice!");
   }
}

public class Cat extends Animal {

   @Override
   public void voice() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void voice() {
       System.out.println("Woof!");
   }
}

Sa mga klase Catat Dogna-override namin ang paraan ng parent class. Ngayon ang hayop ay mag-vocalize depende sa kung anong klaseng object ito:

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       Dog dog = new Dog();

       cat.voice();
       dog.voice();
   }
}

Konklusyon: Meow! Woof! Gayunpaman, kung Animalidedeklara namin ang isang pamamaraan sa isang klase voice()bilang final, hindi ito magiging posible na muling tukuyin ito sa ibang mga klase:

public class Animal {

   public final void voice() {
       System.out.println("Voice!");
   }
}


public class Cat extends Animal {

   @Override
   public void voice() {//ошибка! final-метод не может быть переопределен!
       System.out.println("Meow!");
   }
}

Pagkatapos ang aming mga bagay ay mapipilitang gamitin ang pamamaraan voice()tulad ng tinukoy sa parent class:

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   cat.voice();
   dog.voice();
}

Konklusyon: Boses! Boses! Ngayon tungkol finalsa -variables. Kung hindi man sila ay tinatawag na constants . Una (at pinaka-mahalaga), ang unang halaga na itinalaga sa isang pare-pareho ay hindi mababago. Ito ay itinalaga minsan at magpakailanman.

public class Main {

   private static final int CONSTANT_EXAMPLE = 333;

   public static void main(String[] args) {

       CONSTANT_EXAMPLE = 999;//ошибка! Нельзя присвоить новое meaning final-переменной!
   }
}

Ang pare-pareho ay hindi kailangang masimulan kaagad. Magagawa ito mamaya. Ngunit ang halaga na unang itinalaga ay mananatili magpakailanman.

public static void main(String[] args) {

   final int CONSTANT_EXAMPLE;

   CONSTANT_EXAMPLE = 999;//так делать можно
}

Pangalawa, bigyang-pansin ang pangalan ng aming variable. Ang mga constant ng Java ay may ibang kombensyon sa pagbibigay ng pangalan. Hindi ito ang nakasanayan nating camelCase. Sa kaso ng isang regular na variable, tatawagin natin itong constantExample, ngunit ang mga pangalan ng constants ay nakasulat sa caps, at sa pagitan ng mga salita (kung marami sa kanila) ay may underscore - "CONSTANT_EXAMPLE". Bakit kailangan ang mga constants? Halimbawa, magiging kapaki-pakinabang ang mga ito kung patuloy kang gumagamit ng ilang pare-parehong halaga sa isang programa. Sabihin nating nagpasya kang pumunta sa kasaysayan at isulat ang larong "The Witcher 4" nang mag-isa. Ang laro ay malinaw na patuloy na gagamitin ang pangalan ng pangunahing karakter - "Geralt of Rivia". Mas mainam na paghiwalayin ang linyang ito at ang mga pangalan ng iba pang mga bayani sa isang pare-pareho: ang halaga na kailangan mo ay maiimbak sa isang lugar, at tiyak na hindi ka magkakamali kapag nagta-type nito sa ika-isang milyong beses.

public class TheWitcher4 {

   private static final String GERALT_NAME = "Геральт из Ривии";
   private static final String YENNEFER_NAME = "Йеннифэр из Венгерберга";
   private static final String TRISS_NAME = "Трисс Меригольд";

   public static void main(String[] args) {

       System.out.println("Ведьмак 4");
       System.out.println("Это уже четвертая часть Ведьмака, а " + GERALT_NAME + " ниHow не определится кто ему" +
               " нравится больше: " + YENNEFER_NAME + " or " + TRISS_NAME);

       System.out.println("Но если вы никогда не играли в Ведьмака - начнем сначала.");
       System.out.println("Главного героя зовут " + GERALT_NAME);
       System.out.println(GERALT_NAME + " - ведьмак, охотник на чудовищ");
   }
}

Konklusyon:

Ведьмак 4
Это уже четвертая часть Ведьмака, а Геральт из Ривии ниHow не определится, кто ему нравится больше: Йеннифэр из Венгерберга or Трисс Меригольд.
Но если вы никогда не играли в Ведьмака — начнем сначала.
Главного героя зовут Геральт из Ривии
Геральт из Ривии — ведьмак, охотник на чудовищ

Pinaghiwalay namin ang mga pangalan ng mga character sa mga constant, at ngayon ay tiyak na hindi namin mali ang spell ng mga ito, at hindi na kailangang isulat ang mga ito sa bawat oras. Isa pang plus: kung sa kalaunan ay kailangan nating baguhin ang halaga ng isang variable sa buong programa, sapat na na gawin ito sa isang lugar, sa halip na manu-manong gawin ito sa buong code :)

Mga uri na hindi nababago

Sa iyong oras na nagtatrabaho sa Java, malamang na sanay ka na sa katotohanan na halos ganap na kinokontrol ng programmer ang estado ng lahat ng mga bagay. Wanted - lumikha ng isang bagay Cat. Kung gusto ko, pinalitan ko ito ng pangalan. Kung gusto niya, binago niya ang kanyang edad, o iba pa. Ngunit sa Java mayroong ilang mga uri ng data na may espesyal na estado. Ang mga ito ay hindi nababago , o hindi nababago . Nangangahulugan ito na kung ang isang klase ay hindi nababago, ang estado ng mga bagay nito ay hindi mababago. Mga halimbawa? Maaari kang mabigla, ngunit ang pinakatanyag na halimbawa ng klase ng Immutable ay String! Mukhang hindi natin mababago ang halaga ng isang string? Subukan Natin:

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;//обе переменные-ссылки указывают на одну строку.
   System.out.println(str2);

   str1 = "I love Python";//но поведение str1 ниHow не влияет на str2
   System.out.println(str2);//str2 продолжает указывать на строку "I love Java", хотя str1 уже указывает на другой an object
}

Konklusyon: Mahal ko ang Java Mahal ko ang Java Pagkatapos naming isulat:

str1 = "I love Python";

ang bagay na may string na "I love Java" ay hindi nagbago at hindi napunta kahit saan. Ligtas itong umiiral at may eksaktong parehong teksto sa loob nito gaya ng dati. Code:

str1 = "I love Python";

lumikha lang ng isa pang bagay at ngayon ay str1itinuturo ito ng variable. Ngunit hindi namin maimpluwensyahan ang bagay na "Mahal ko ang Java" sa anumang paraan. Okay, subukan natin ito nang iba! Ang klase Stringay puno ng mga pamamaraan, at ang ilan sa mga ito ay tila binabago ang estado ng row! Halimbawa, mayroong isang pamamaraan replace(). Palitan natin ang salitang “Java” ng salitang “Python” sa ating linya!

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;//обе переменные-ссылки указывают на одну строку.
   System.out.println(str2);

   str1.replace("Java", "Python");//попробуем изменить состояние str1, заменив слово "Java" на “Python”
   System.out.println(str2);
}

Konklusyon: Gustung-gusto ko ang Java Gusto ko ang Java Hindi na ito gumana muli! Baka hindi gumana ang curve method? Subukan natin ang isa pa. Halimbawa, substring(). Pinuputol ang isang string batay sa mga numero ng ipinadalang mga character. I-trim natin ang atin sa unang 10 character:

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;//обе переменные-ссылки указывают на одну строку.
   System.out.println(str2);

   str1.substring(10);//обрезаем исходную строку
   System.out.println(str2);
}

Konklusyon: Mahal ko ang Java Mahal ko ang Java Walang nagbago. At hindi dapat. Tulad ng sinabi namin, ang mga bagay Stringay hindi nababago. Ano ang lahat ng mga pamamaraan ng klase na ito String? Maaari nilang i-trim ang linya, baguhin ang mga character dito, atbp. Bakit kailangan nila kung walang mangyayari? Kaya nila! Ngunit nagbabalik sila ng bagong string object sa bawat oras. Walang silbi ang pagsusulat:

str1.replace("Java", "Python");

- hindi mo babaguhin ang orihinal na bagay. Ngunit kung isusulat mo ang resulta ng pamamaraan sa isang bagong reference variable, makikita mo kaagad ang pagkakaiba!

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;//обе переменные-ссылки указывают на одну строку.
   System.out.println(str2);

   String str1AfterReplacement =  str1.replace("Java", "Python");
   System.out.println(str2);

   System.out.println(str1AfterReplacement);
}

Ito ang tanging paraan Stringna gumagana ang lahat ng mga pamamaraang ito. Wala kang magagawa sa object na "I love Java" . Gumawa lang ng bagong object at isulat ang: “Bagong object = resulta ng ilang manipulasyon sa object na “I love Java” . Anong iba pang mga uri ang hindi nababago? Mula sa kung ano ang talagang kailangan mong tandaan ngayon - lahat ng mga klase ng wrapper sa mga primitive na uri ay hindi nababago. Integer, Byte, Character, Short, Boolean, Long, Double, Float- lahat ng klaseng ito ay lumilikha ng mga hindi nababagong bagay. Kasama rin dito ang mga klase na ginagamit upang lumikha ng malalaking numero - BigIntegerat BigDecimal. Kamakailan ay dumaan kami sa mga eksepsiyon at nakipag-ugnayan sa StackTrace. Kaya: ang mga bagay ng klase ng java.lang.StackTraceElement ay hindi rin nababago. Ito ay lohikal: kung ang isang tao ay maaaring magbago ng data sa aming stack, maaari nitong pabayaan ang lahat ng trabaho dito. Isipin na may pumasok sa StackTrace at binago ang OutOfMemoryError sa FileNotFoundException . At dapat kang magtrabaho kasama ang stack na ito at hanapin ang sanhi ng error. At ang programa ay hindi gumagamit ng mga file sa lahat :) Samakatuwid, upang maging sa ligtas na bahagi, ang mga bagay na ito ay ginawang hindi nababago. Well, sa StackTraceElement ito ay higit pa o hindi gaanong malinaw. Bakit may gustong gawing hindi nababago ang mga string? Ano ang magiging problema kung posible na baguhin ang kanilang mga halaga. Ito ay malamang na maging mas maginhawa :/ Mayroong ilang mga dahilan para dito. Una, pag-save ng memorya. Ang mga hindi nababagong string ay maaaring ilagay String Poolat ang parehong mga string ay maaaring gamitin sa bawat oras sa halip na lumikha ng mga bago. Pangalawa, kaligtasan. Halimbawa, karamihan sa mga login at password sa anumang programa ay mga string. Ang posibilidad na baguhin ang mga ito ay maaaring humantong sa mga problema sa awtorisasyon. May iba pang mga dahilan, ngunit hindi pa namin nauunawaan ang mga ito sa pag-aaral ng Java—babalik kami mamaya.