Mga literal sa Java

1. Integer na literal

At ngayon para sa isang bagong kawili-wiling paksa — literal. Ang data na nakasulat nang direkta sa program code ay tinatawag na literals . Hindi namin pinag-uusapan ang tungkol sa anumang lumang data, ngunit ang mga halaga ng mga primitive na uri at ang Stringuri.

Halimbawa, ipagpalagay na mayroon kang sumusunod na code:

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 10at ang string na ' Sum = '.

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

Higit pa rito, kung magpasya kang magtalaga ng integer literal sa isang byte variable o isang maikling variable sa iyong code, walang magiging problema. Kailangan mo lang tiyakin na ang literal na halaga ay nasa hanay ng mga halaga na maaaring iimbak ng uri ng variable.

Ang Java compiler ay sapat na matalino upang maunawaan na ang isang bytevariable ay maaaring italaga ng integer literal na 100 nang hindi lumilikha ng mga problema.

Mga halimbawa:

int a = 300;

byte a = 100; 

byte a = 300; 

Maaari ka ring magsulat ng longmga literal sa iyong code. Upang gawin ito, idagdag ang Latin na titik na '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 digit? Hindi mo agad masasabi kung 3 bilyon o 30 bilyon ang sinasabi ng code. 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; 

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 ng isang paraan.

2. Real number literals

Sa iyong code, maaari mong tukuyin hindi lamang ang mga integer, kundi pati na rin ang mga floating-point na literal (mga totoong numero).

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 literal. At hindi lang basta literal, kundi doubleliteral.

Maaari kang lumikha ng float literal, ngunit kailangan mong ilagay ang titik na 'F' (o 'f') sa dulo ng numero upang magawa iyon .

Mga halimbawa:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

Sa pamamagitan ng paraan, maaari mong tahasang i-convert ang isang integer literal sa float o double literal sa pamamagitan lamang ng ). Mga halimbawa: appending the suffix 'F' (for float) or D (for double)

double a = 100D; 

float a = 100F; 

int a = 300D; 

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

1.23E2

1.23 * 102

123.0

1.23E3

1.23 * 103

1230.0

1.23E-6

1.23 * 10-6

0.00000123

1E6

1.0 * 106

1000000.0

1E-10

1.0 * 10-10

0.0000000001

3. 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 double quotation mark ay nagpapahiwatig ng simula ng isang literal. Ang susunod ay nagpapahiwatig ng katapusan ng literal. Ang susunod na pagkatapos nito ay muling minarkahan ang simula ng isang bagong literal. At ang susunod ay nagmamarka ng pagtatapos ng pangalawang literal. At iba pa.

Ang bawat ganoong 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.";

4. Mga literal na karakter

Maaari mong tukuyin hindi lamang ang mga string literal sa iyong code, ngunit pati na rin ang mga literal na binubuo ng mga indibidwal na character. Tandaan na hindi namin pinag-uusapan ang tungkol sa isang string na binubuo ng isang character, ngunit sa halip tungkol sa mga literal na ang uri ay char.

Hindi tulad ng isang string, ang literal na character ay napapalibutan ng mga solong panipi . Sa loob ng nag-iisang quote ay dapat mayroong isang karakter at isang karakter lamang. Hindi ka maaaring gumamit ng mga walang laman na solong panipi.

Mga halimbawa:

'A'

'@' 

'本' 

'\u1f3a'

Ang huling halimbawa ay nagtatalaga ng isang Unicode na character gamit ang isang espesyal na notasyon: una ay mayroon tayong prefix \u, na sinusundan ng 4 na hexadecimal na character. Kasama sa susunod na mga aralin ang detalyadong impormasyon tungkol dito.