Mga literal sa Java

"Amigo, naiinggit ako sa iyo. Ang pag-aaral ng mga bagong bagay ay napakaganda! At ngayong araw ay naghihintay sa iyo ang isang bago at kawili-wiling paksa — literal."

"Mukhang dapat kong sabihin na ako ang pinakamasayang robo-student sa planeta, Rishi. Well, handa akong sumipsip ng bagong kaalaman!"

"Puntahan natin ito kaagad. Ang mga literal ay mga tiyak na data na direktang nakasulat sa code ng isang programa. Hindi namin pinag-uusapan ang tungkol sa anumang data lamang. Ang pinag-uusapan lang namin ay tungkol sa mga primitive na uri at Strings.

Halimbawa, ipagpalagay na mayroon kang code na ito:

int a = 5;
int b = a + 10;
String s = "Sum=" + (a + b);

5
10
"Sum="

"Ang mga literal sa code na ito ay ang numero 5 , ang numero 10 at ang string na ' Sum = '.

Mga literal na integer

"Sa Java, lahat, kabilang ang mga literal, ay may uri. Ang lahat ng integer literal (mga integer) sa code ay ints . Ang uri ng int ay ang karaniwang uri ng Java integer."

"I know this type. Nagamit ko na."

"Naaalala mo ba ang iba pang mga uri ng integer bukod sa int? Ang ilan ay kumukuha ng mas kaunting espasyo sa memorya?"

"Oo naman! Byte and short."

"Iyan ang mga iyon. Kaya, kung sa iyong code ay nagpasya kang magtalaga ng integer literal sa isang variable ng uri ng byte o maikli, walang magiging problema. Ang pangunahing bagay ay ang literal na halaga ay nasa loob ng hanay ng mga halaga na Ang uri ng variable ay maaaring mag-imbak. Ang Java compiler ay sapat na matalino upang maunawaan na ang isang byte variable ay maaaring italaga ng integer literal na 100.

Mga halimbawa:

int a = 300;

byte a = 100; 

byte a = 300; 

"Ano ang tungkol sa mahabang uri?"

"Maaari rin kaming magsulat ng mga literal na ganitong uri sa aming code. Upang gawin ito, idagdag ang Latin na letrang 'L' o 'l' sa dulo ng integer.

Mga halimbawa:

long a = 3000000000L; 

long a = 3000000000; 

int a = 3000000000L; 

"Napansin mo ba kung gaano kahirap basahin ang malalaking numero ng 10 o higit pang mga numero?

"Oo, kung hindi mo pinagana ang iyong robovision, hindi agad malinaw kung 3 bilyon o 30 ang pinag-uusapan natin."

"Upang gawing mas nababasa ang code (at ito ay mahalaga!), Pinapayagan ng Java ang mga underscore na maipasok sa mga literal na numero (hindi ito nakakaapekto sa halaga ng numero).

"Ang halimbawa sa itaas ay maaaring muling isulat gamit ang mga salungguhit upang maging mas malinaw ito:

long a = 3_000_000_000L; 

long a = 3_000_000_000; 

int a = 3_000_000_000L; 

"Ito ay mas maginhawang basahin, kahit na isang kuwit sa halip na isang underscore ay magiging mas pamilyar!"

"Ngunit hindi kami maaaring gumamit ng mga kuwit sa mga literal na numero dahil ginagamit na ang mga ito para sa ibang layunin. Halimbawa, para sa paghihiwalay ng mga argumento sa isa't isa kapag tumatawag sa isang pamamaraan.

Mga literal na tunay na numero

"Marahil nahulaan mo na sa iyong code maaari mong tukuyin hindi lamang ang mga integer, kundi pati na rin ang mga floating point na literal (mga tunay na numero)."

"Parehong doubles at floats?"

"Oo. Sa totoo lang, ang panuntunan ay medyo simple: kung ang isang numero sa code ay may decimal point dito, kung gayon ang numero ay isang floating point na literal. At hindi lamang anumang literal, ngunit double literal. Upang lumikha ng float literal , ikaw kailangang ilagay ang letrang 'F' (o 'f') sa dulo ng numero .

Mga halimbawa:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

"Siya nga pala, maaari mong tahasang i-convert ang integer literal sa float o double literal sa pamamagitan lamang ng pagdaragdag ng suffix na 'F' (para sa float ) o D (para sa double ). Mga Halimbawa:

double a = 100D; 

float a = 100F; 

int a = 300D; 

"Ang mga literal na floating-point ay maaaring gumamit ng siyentipikong notasyon : bilang karagdagan sa nilagdaang bahagi ng numero, maaari ka ring tumukoy ng kapangyarihan ng sampu. Halimbawa:

Mga literal na string

"Maaari mo ring tukuyin ang buong linya ng teksto sa iyong code. Upang sabihin sa compiler na ituring ang isang string bilang data (isang literal) at hindi bilang bahagi ng code, ang buong string ay napapalibutan ng mga dobleng panipi sa magkabilang panig.

"Kung ang isang linya ng code ay may ilang dobleng panipi, kung gayon ang mga ito ay nahahati sa mga pares. Ang unang dobleng panipi ay nagpapahiwatig ng simula ng isang literal. Ang susunod na isa ay nagpapahiwatig ng katapusan ng literal. Ang susunod na isa pagkatapos nito ay muling minarkahan ang simula ng bagong literal.At ang kasunod ay nagmamarka ng katapusan ng pangalawang literal.At iba pa.

"Ang bawat literal ay isang String .

Mga halimbawa

"+"+"+"+"+"+"+"+"+"

""

"2+3"+"-5"

"return"+";"

"Kung masyadong mahaba ang literal na string, maaari itong hatiin sa ilang linya at idikit kasama ng 'plus operator':

String s = "I hold it true, whate'er befall"
         + "I feel it when I sorrow most;"
         + "'Tis better to have loved and lost"
         + "Than never to have loved at all.";

Mga literal na karakter

"Paano kung kailangan ko ng literal na isang character sa halip na isang string? Dapat ba akong gumawa ng string na binubuo ng isang character?"

"Hindi, kung gayon kailangan mo ng literal na ang uri ay char. Maaari mo bang hulaan kung paano itinalaga ang simula at wakas ng gayong literal?"

"Single quotes?"

"Oo, at sa loob ng single quotes dapat may character at isang character lang. Hindi ka pwedeng gumamit ng walang laman na single quotes.

Mga halimbawa:

'A'

'@' 

'本' 

'\u1f3a'

"Ang huling halimbawa ay nagtatalaga ng isang Unicode na character gamit ang isang espesyal na notasyon: una ay mayroon kaming prefix \u, na sinusundan ng 4 na hexadecimal na mga character. Matututo ka pa tungkol dito sa mga susunod na aralin."