CodeGym /Kurso sa Java /Modyul 1 /Mga literal sa Java

Mga literal sa Java

Modyul 1
Antas , Aral
Available

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:

Code Mga literal
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:

Code Paglalarawan
int a = 300;
Ito ay mag-compile nang maayos.
byte a = 100; 
Ito ay mag-compile nang maayos.
byte a = 300; 
Magkakaroon ng error sa compilation, dahil ang maximum byte value ay 127.

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:

Code Paglalarawan
long a = 3000000000L; 
Ito ay mag-compile nang maayos.
long a = 3000000000; 
Error sa compilation: Masyadong malaki ang 3 bilyon para sa isang int literal.
int a = 3000000000L; 
Error sa compilation: ang literal ay mahaba, ngunit ang variable ay isang int. Bukod pa rito, ang 3 bilyon ay higit pa sa maximum na int.

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:

Code Paglalarawan
long a = 3_000_000_000L; 
Ito ay mag-compile nang maayos.
long a = 3_000_000_000; 
Error sa compilation: Masyadong malaki ang 3 bilyon para sa isang int literal.
int a = 3_000_000_000L; 
Error sa compilation: ang literal ay mahaba, ngunit ang variable ay isang int. Bukod pa rito, ang 3 bilyon ay higit pa sa maximum na int.

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:

Code Paglalarawan
double a = 100.0; 
Ito ay mag-compile nang maayos.
double a = 100.;
Ito ay mag-compile nang maayos.
double a = .0;
Ito ay mag-compile nang maayos.
float a = 100.0f; 
Ito ay mag-compile nang maayos.
float a = 100.0; 
Magkakaroon ng error sa compilation: ang variable ay float, ngunit ang literal ay double.

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)

Code Paglalarawan
double a = 100D; 
Ito ay mag-compile nang maayos.
float a = 100F; 
Ito ay mag-compile nang maayos.
int a = 300D; 
Magkakaroon ng error sa compilation: ang variable ay isang int, ngunit ang literal ay isang double.

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:

Literal matematikal na notasyon Panghuling halaga
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

Code Paliwanag
"+" + "+" + "+" + "+" + "+"
Mayroong 5 literal sa isang linya. Ang bawat isa sa kanila ay binubuo ng isang  +karakter
""
Ang literal na ito ay isang walang laman na string. Isang string na walang mga character.
"2+3" + "-5"
Mayroong dalawang literal dito. Ang magiging resulta ay ang string na ' 2+3-5', hindi isang numero
"return" + ";"
Mayroon ding dalawang literal dito. Walang return statement dito.

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

Code Paliwanag
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.";
Kung ilalabas mo ang linyang ito sa screen, ang lahat ng teksto ay ipapakita sa isang linya!


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:

Code Paliwanag
'A'
Isang literal na ang uri ay char. Naglalaman ito ng Latin na letrang 'A'.
'@' 
Isang literal na ang uri ay char. Naglalaman ito ng simbolo na '@'
'' 
Isang literal na ang uri ay char. Naglalaman ito ng karakter ng Hapon. At ito ay posible rin.
'\u1f3a'
Isang literal na ang uri ay char. Naglalaman ito ng isang Unicode na character na tinukoy ng numero nito.

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.


Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION