Literal sa Java

Sa yugto ng paglikha ng isang application, ang developer, bilang panuntunan, ay nakakaalam lamang ng istraktura nito at hindi ipinapalagay kung anong data ang ipoproseso nito. Gayunpaman, sa ilang sitwasyon, kailangan mong tahasang tukuyin ang ilang data sa program code (halimbawa, ang bilang ng mga pag-ulit o ang mensaheng ilalabas). Sa kasong ito, ang mga literal ay dumating upang iligtas. Nilalaman:

• Ano ang mga literal
• Mga uri ng literal at gamit nito
• Mga literal na numero
• Mga literal na string
• Mga literal na karakter
• Boolean literals
• Jedi technique na may mga literal
• Mga literal sa kursong JavaRush
• Konklusyon

Ano ang mga literal?

Ang mga literal ay tahasang tinukoy na mga halaga sa code ng programa - mga constant ng isang tiyak na uri na nasa code sa oras ng paglulunsad.

class Test {
   public static void main(String[] args) {
       System.out.println("Hello world!");
   }
}

Sa klase na ito "Hello world!" - literal. Ang mga literal ay may iba't ibang uri, na tinutukoy ng kanilang layunin at kung paano sila isinulat.

Mga uri ng literal at gamit nito

Ang lahat ng mga literal ay primitive na halaga (mga string, numero, character, boolean). Hindi ka makakagawa ng literal na bagay. Ang tanging literal na nauugnay sa isang bagay ay null. Ayon sa primitives, ang mga literal ay nahahati din sa mga seksyon:

1. Numeric:
   • Integers;
   • Lumulutang na punto;
2. String;
3. Karakter;
4. Panunukso ng utak.

Mga literal na numero

Mga literal na integer

Ang ganitong uri ng literal ang pinakasimple. Ang mga numero ay isinulat sa kanilang karaniwang anyo nang hindi nagpapahiwatig ng mga character o anumang bagay. Ang anumang integer ay isang integer literal bilang default. Iyon ay, maaari mong tahasang itakda ang halaga ng isang variable o ang bilang ng mga pag-ulit sa isang loop. Sinusuportahan ng Java ang 4 na sistema ng numero:

• Binary
• Octal
• Decimal
• Hexadecimal

Ipinakilala ng JDK 7 ang kakayahang magsulat ng mga binary na halaga. Ginagawa ito gamit ang prefix na 0b o 0B . Susunod ang pagsusulat gamit ang 0 at 1. Ang mga numero sa octal ay isinusulat gamit ang leading 0. Ang mga wastong digit ay 0 hanggang 7. Ang pagsulat ng 09 o 08 ay magdudulot ng error sa compilation. Walang mga problema sa sistema ng decimal na numero: ang mga numero ay ipinahiwatig sa form na pamilyar sa amin. Ang tanging limitasyon ay ang numero ay hindi maaaring magsimula sa 0, dahil kukunin ito ng compiler bilang octal. Ang mga numero sa hexadecimal ay isinusulat gamit ang mga prefix na 0x at 0X. Ang mga wastong numero ay mula 0 hanggang 15, kung saan ang mga numero 10-15 ay ipinahiwatig ng mga simbolo ng AF ayon sa pagkakabanggit.

public static void main(String[] args) {
       int a = 0b1101010110;
       int b = 012314;
       int c = 456;
       int d = 0x141D12;
       System.out.println("Число a в двоичной системе: " + a);
       System.out.println("Число b в восьмеричной системе: " + b);
       System.out.println("Число c в десятичной системе: " + c);
       System.out.println("Число d в шестнадцатеричной системе: " + d);
}

Output: Numero a sa binary system: 854 Number b sa octal system: 5324 Number c sa decimal system: 456 Number d sa hexadecimal system: 1318162 Sa kabila ng katotohanan na ang mga numero ay tinukoy sa iba't ibang mga sistema ng numero, sa programa ang mga ito ay pinoproseso bilang decimal numero. Ang paglampas sa mga halaga ay magreresulta sa isang error sa compilation:

int b = 012914; // Ошибка
int d = 0x141Z12; // Ошибка

Kapag tumakbo sa yugto ng compilation, nakukuha namin ang sumusunod na resulta:

Error:(13, 25) java: integer number too large: 012914
Error:(14,30) java: ';' expected

Paano ang pag-type? Ang anumang integer literal ay may default na uri ng int. Kung ang halaga nito ay nasa labas ng mga hangganan ng itinalagang variable, may magaganap na error sa compilation. Kapag gumagamit ng isang uri, longdapat kang maglagay ng simbolo sa dulo Lna nagsasaad ng ganitong uri:

long x = 0x1101010110; // Ошибка
long b = 1342352352351351353L; // Все в порядке

Sinusubukang mag-compile ng mga resulta sa sumusunod na error:

Error(11, 26) java: integer number too large: 1101010110

Mga literal na floating point

Ang mga floating point na numero, o mga fractional na numero, ay maaaring isulat sa dalawang paraan. Ang una ay bilang isang klasikong decimal fraction: 3.14159 o 2.718281282459045. Ang pangalawa ay nasa siyentipikong anyo, iyon ay, isang ordinaryong decimal fraction kasama ang isang suffix sa anyo ng simbolo na e o E at ang kapangyarihan ng 10 kung saan ang tinukoy na fraction ay dapat na i-multiply. Halimbawa, 4.05E-13, nangangahulugan ito ng 4.05 * 10 ^-13 .

double a = 2.718281828459045;
double d = 4.05E-13;
System.out.println("Тип double в классическом виде: " + a);
System.out.println("Тип double в научном виде: " + d);

Output: Classic double type: 2.718281828459045 Scientific double type: 4.05E-13 Hindi tulad ng mga integer at number system, ang scientific notation ay iniimbak sa isang variable at pinoproseso sa parehong paraan tulad ng classical notation. Paano ang pag-type? Ang anumang numero ng floating point ay lumilikha ng isang uri double. Kung kailangan mong gamitin ang uri float, dapat kang magdagdag ng fo sa dulo F. Sa kasong ito, doublemababawasan ito sa uri float. Hindi ito awtomatikong nangyayari:

float a = 2.718281828459045; // Ошибка
float d = 4.05E-13F; // Все в порядке

Kapag nagsisimula sa yugto ng compilation, nakikita namin ang sumusunod na error:

Error:(11, 27) java: incompatible types: possible lossy conversion from double to float

Mga literal na string

Ang mga string literal ay isang set ng mga character na nakapaloob sa double quotes. Ang ganitong uri ay ginagamit nang kasingdalas ng mga literal na numero. Ang linya ay maaari ding maglaman ng mga character ng serbisyo na kailangang i-escape (tinatawag na mga escape sequence). Halimbawa:

String simpleString = "Это обычная строка. Такая же стандартная и непримечательная, How и все мы.";
String uniqueString = "А это необычная \"строка\". Хотя бы потому, что часть \"слов\" в ней в \"кавычках\".";
System.out.println(simpleString);
System.out.println(uniqueString);

Output: Ito ay isang normal na string. Tulad ng karaniwan at hindi kapansin-pansin tulad ng iba sa amin. At ito ay isang hindi pangkaraniwang "linya". Kung ang ilan sa mga "salita" dito ay nasa "quotes".

Mga literal na karakter

Ang mga literal ng character sa Java ay kinakatawan ng Unicode character set, ibig sabihin, ang bawat character ay isang 16-bit na halaga. Upang ipahiwatig ang isang simbolo sa code, ito ay pinaghihiwalay ng mga solong quote. Batay sa karanasan, mayroong dalawang uri ng mga simbolo:

1. Ang mga maaaring ipasok mula sa keyboard ay mga ordinaryong character;
2. Mga simbolo na hindi basta basta maipasok mula sa keyboard (mga simbolo ng iba't ibang wika, hugis, at iba pa).

Ang mga regular na character ay maaaring tahasang tukuyin: ' ,' o ' @'. Kung ang isang character ay isang service character (halimbawa, isang line break o tab), ang naturang character ay dapat na i-escape gamit ang isang backslash. Ang mga character na hindi basta basta maipasok mula sa console ay maaaring tukuyin sa kanilang 16-bit na form. Upang gawin ito, dapat mong tukuyin ang code ng character na may prefix \u, halimbawa ' \u00F7'. Maaari mo ring tukuyin ang mga character sa istilong octal (tatlong digit na numero) sa pamamagitan lamang ng pagdaragdag ng backslash sa simula, halimbawa ' \122'. Sa palagay ko, mas madaling gamitin ito \u. Halimbawa ng paggamit:

System.out.println("Амперсанд - " + '&');
System.out.println("Символ деления - " + '\u00F7');

Output: Ampersand - & simbolo ng Division - ÷

Boolean literals

Ang pinakasimpleng literal ay isang lohikal. Mayroon lamang 2 mga halaga: falseat true, na tahasang tinukoy nang walang iba't ibang mga simbolo. Ang ganitong mga literal ay maaaring italaga sa mga variable ng uri ng boolean o tinukoy sa isang lugar kung saan ang uri ng boolean ay inaasahan (halimbawa, sa isang if block, bagama't ang kasanayang ito ay itinuturing na hindi magandang asal, upang ilagay ito nang mahinahon).

boolean flag = false;

if(true) {
    // Действия будут выполняться всегда.
}

Jedi technique na may mga literal

Salamat sa mga simbolo sa Java, makakagawa ka ng maraming kawili-wiling bagay, kabilang ang pamamahala ng mga emoji. Halimbawa, ipakita natin ang nakangiting mukha:

int smile = 0x1F600; // Здесь шестнадцатеричный code эмоджи
StringBuilder sb = new StringBuilder();
sb.append(Character.toChars(smile)); // Собираем в StringBuilder
System.out.println("Улыбающееся лицо: " + sb.toString()); // Выводим

Konklusyon: Nakangiting mukha: 😀 Kahit na ang pagpapakita ng emoji ay maaaring maging katakut-takot (depende sa pagpapatupad), ang solusyon na ito ay gumagana nang maayos. Gayunpaman, mahirap hanapin ang nais na emoji sa karaniwang talahanayan ng pag-encode; ang seksyon ng Emoticon sa opisyal na website ay kalat-kalat. Mas madaling gumamit ng mga karagdagang aklatan.

Mga literal sa kursong JavaRush

Sa kursong JavaRush, ang mga literal ay pinag-aaralan sa antas 10 sa lecture 8 ng kursong Java Syntax , kung saan ipinapaliwanag ng mga halimbawa kung ano ang mga literal at kung bakit kailangan ang mga ito. Ang JavaRush ay isang online na kurso sa Java programming na may diin sa pagsasanay: 1200+ gawain na may agarang pag-verify, mini-proyekto, mga laro.

Konklusyon

Ang mga literal sa Java ay isang maginhawang bagay sa anumang programa, ngunit dapat itong gamitin sa mga lugar kung saan ito naaangkop. Hindi mo dapat i-hardcode ang mga parameter ng koneksyon sa database o anumang mga halaga na maaaring magbago sa panahon ng ikot ng buhay ng programa sa source code.