జావాలో అక్షరాలు

1. పూర్ణాంక అక్షరాలు

మరియు ఇప్పుడు కొత్త ఆసక్తికరమైన అంశం కోసం — అక్షరాలు. ప్రోగ్రామ్ కోడ్‌లో నేరుగా వ్రాసిన డేటాను లిటరల్స్ అంటారు . మేము ఏ పాత డేటా గురించి మాట్లాడటం లేదు, కానీ ఆదిమ రకాలు మరియు రకం విలువలు String.

ఉదాహరణకు, మీరు ఈ క్రింది కోడ్‌ని కలిగి ఉన్నారని అనుకుందాం:

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

5
10
"Sum="

ఈ కోడ్‌లోని అక్షరాలు సంఖ్య , సంఖ్య మరియు స్ట్రింగ్ ' ' .510Sum =

జావాలో, అక్షరాలతో సహా ప్రతిదానికీ ఒక రకం ఉంటుంది. డిఫాల్ట్‌గా, కోడ్‌లోని అన్ని పూర్ణాంకాల అక్షరాలు (పూర్తి సంఖ్యలు) ints. పూర్ణాంక రకం ప్రామాణిక జావా పూర్ణాంకం రకం.

ఇంకా ఏమిటంటే, మీరు మీ కోడ్‌లో బైట్ వేరియబుల్ లేదా షార్ట్ వేరియబుల్‌కు అక్షరార్థంగా పూర్ణాంకాన్ని కేటాయించాలని నిర్ణయించుకుంటే, ఎటువంటి సమస్యలు ఉండవు. వేరియబుల్ రకం నిల్వ చేయగల విలువల పరిధిలోనే అక్షర విలువ ఉండేలా మీరు నిర్ధారించుకోవాలి.

byteజావా కంపైలర్ సమస్యలను సృష్టించకుండా వేరియబుల్‌కు పూర్ణాంకం అక్షరాలా 100 కేటాయించవచ్చని అర్థం చేసుకునేంత తెలివైనది .

ఉదాహరణలు:

int a = 300;

byte a = 100; 

byte a = 300; 

longమీరు మీ కోడ్‌లో అక్షరాలను కూడా వ్రాయవచ్చు . దీన్ని చేయడానికి, పూర్ణాంకం చివరిలో లాటిన్ అక్షరం 'L' లేదా 'l'ని జోడించండి.

ఉదాహరణలు:

long a = 3000000000L; 

long a = 3000000000; 

int a = 3000000000L; 

10 లేదా అంతకంటే ఎక్కువ అంకెలు ఉన్న పెద్ద సంఖ్యలను చదవడం ఎంత కష్టమో మీరు గమనించారా? కోడ్ 3 బిలియన్ లేదా 30 బిలియన్ అని మీరు వెంటనే చెప్పలేరు. కోడ్‌ను మరింత చదవగలిగేలా చేయడానికి (మరియు ఇది ముఖ్యమైనది!), జావా అండర్‌స్కోర్‌లను సంఖ్యా అక్షరాలలోకి చొప్పించడానికి అనుమతిస్తుంది (అవి సంఖ్య విలువను ప్రభావితం చేయవు).

పైన ఉన్న ఉదాహరణను కొంచెం స్పష్టంగా చేయడానికి అండర్‌స్కోర్‌లతో తిరిగి వ్రాయవచ్చు:

long a = 3_000_000_000L; 

long a = 3_000_000_000; 

int a = 3_000_000_000L; 

కానీ మేము కామాలను సంఖ్యా అక్షరాలలో ఉపయోగించలేము ఎందుకంటే అవి ఇప్పటికే మరొక ప్రయోజనం కోసం ఉపయోగించబడ్డాయి. ఉదాహరణకు, ఒక పద్ధతిని పిలిచేటప్పుడు ఒకదానికొకటి వాదనలను వేరు చేయడానికి.

2. వాస్తవ సంఖ్య అక్షరాలు

మీ కోడ్‌లో, మీరు పూర్ణాంకాలనే కాకుండా, ఫ్లోటింగ్ పాయింట్ లిటరల్స్ (వాస్తవ సంఖ్యలు) కూడా పేర్కొనవచ్చు.

వాస్తవానికి, నియమం చాలా సులభం: కోడ్‌లోని ఒక సంఖ్య దానిలో దశాంశ బిందువును కలిగి ఉంటే, ఆ సంఖ్య ఒక ఫ్లోటింగ్ పాయింట్ అక్షరార్థం. మరియు ఏదైనా సాహిత్యం మాత్రమే కాదు, doubleఅక్షరార్థం.

మీరు ఫ్లోట్ లిటరల్‌ని సృష్టించవచ్చు, కానీ అలా చేయడానికి మీరు సంఖ్య చివర 'F' (లేదా 'f') అక్షరాన్ని ఉంచాలి .

ఉదాహరణలు:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

మార్గం ద్వారా, మీరు పూర్ణాంకం లిటరల్‌ని స్పష్టంగా ఫ్లోట్‌గా లేదా డబుల్ లిటరల్‌గా మార్చవచ్చు ). ఉదాహరణలు: appending the suffix 'F' (for float) or D (for double)

double a = 100D; 

float a = 100F; 

int a = 300D; 

ఫ్లోటింగ్ పాయింట్ లిటరల్స్ శాస్త్రీయ సంజ్ఞామానాన్ని ఉపయోగించవచ్చు : సంఖ్య యొక్క సంతకం చేసిన భాగానికి అదనంగా, మీరు పది శక్తిని కూడా పేర్కొనవచ్చు. ఉదాహరణ:

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. స్ట్రింగ్ లిటరల్స్

మీరు మీ కోడ్‌లో మొత్తం టెక్స్ట్ లైన్‌లను కూడా పేర్కొనవచ్చు. స్ట్రింగ్‌ను కోడ్‌లో భాగంగా కాకుండా డేటా (అక్షరార్థం)గా పరిగణించమని కంపైలర్‌కు చెప్పడానికి, మొత్తం స్ట్రింగ్ రెండు వైపులా డబుల్ కోట్‌లతో చుట్టుముట్టబడి ఉంటుంది.

ఒకే లైన్ కోడ్ అనేక డబుల్ కోట్‌లను కలిగి ఉంటే, అప్పుడు అవి జతలుగా విభజించబడతాయి. మొదటి డబుల్ కొటేషన్ గుర్తు అక్షరార్థం యొక్క ప్రారంభాన్ని సూచిస్తుంది. తదుపరిది సాహిత్య ముగింపును సూచిస్తుంది. ఆ తర్వాత వచ్చేది మరోసారి కొత్త సాహిత్యానికి నాంది పలికింది. మరియు తదుపరిది రెండవ అక్షరానికి ముగింపుని సూచిస్తుంది. మరియు అందువలన న.

అటువంటి ప్రతి అక్షరం ఒక String.

ఉదాహరణలు

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

""

"2+3" + "-5"

"return" + ";"

ఒక స్ట్రింగ్ లిటరల్ చాలా పొడవుగా ఉంటే, దానిని అనేక పంక్తులుగా విభజించి 'ప్లస్ ఆపరేటర్'తో అతికించవచ్చు:

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. అక్షర అక్షరాలు

మీరు మీ కోడ్‌లో స్ట్రింగ్ లిటరల్స్‌ను మాత్రమే కాకుండా, వ్యక్తిగత అక్షరాలతో కూడిన అక్షరాలను కూడా పేర్కొనవచ్చు. మేము మాట్లాడుతున్నది ఒకే అక్షరంతో కూడిన స్ట్రింగ్ గురించి కాదు, దాని రకం అక్షరాల గురించి char.

స్ట్రింగ్ వలె కాకుండా, అక్షరార్థం అక్షరం చుట్టూ ఒకే కోట్‌లు ఉంటాయి . ఒకే కోట్‌ల లోపల తప్పనిసరిగా ఒక పాత్ర మరియు కేవలం ఒక అక్షరం ఉండాలి. మీరు ఖాళీ సింగిల్ కోట్‌లను ఉపయోగించలేరు.

ఉదాహరణలు:

'A'

'@' 

'本' 

'\u1f3a'

చివరి ఉదాహరణ ప్రత్యేక సంజ్ఞామానాన్ని ఉపయోగించి యూనికోడ్ అక్షరాన్ని కేటాయిస్తుంది: ముందుగా మనకు ఉపసర్గ \u, తర్వాత 4 హెక్సాడెసిమల్ అక్షరాలు ఉంటాయి. తదుపరి పాఠాలు దీని గురించి సవివరమైన సమాచారాన్ని కలిగి ఉంటాయి.