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

"అమిగో, నేను నిన్ను అసూయపడుతున్నాను. కొత్త విషయాలు నేర్చుకోవడం చాలా అద్భుతంగా ఉంది! మరియు ఈ రోజు ఒక కొత్త మరియు ఆసక్తికరమైన అంశం మీ కోసం వేచి ఉంది — అక్షరాలా."

"గ్రహం మీద అత్యంత సంతోషకరమైన రోబో-విద్యార్థిని నేనే అని స్పష్టంగా చెప్పాలి, రిషీ. సరే, నేను కొత్త జ్ఞానాన్ని నానబెట్టడానికి సిద్ధంగా ఉన్నాను!"

"మనం వెంటనే తెలుసుకుందాం. ప్రోగ్రామ్ కోడ్‌లో నేరుగా వ్రాసిన నిర్దిష్ట డేటా లిటరల్స్ . మేము కేవలం ఏదైనా డేటా గురించి మాట్లాడటం లేదు. మేము ఆదిమ రకాలు మరియు స్ట్రింగ్‌ల గురించి మాత్రమే మాట్లాడుతున్నాము.

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

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

5
10
"Sum="

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

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

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

"నాకు ఈ రకం తెలుసు. నేను దీనిని ఉపయోగించాను."

"పూర్ణాంకంతో పాటు ఇతర పూర్ణాంకాల రకాలు మీకు గుర్తున్నాయా? మెమరీలో తక్కువ స్థలాన్ని తీసుకునే కొన్ని?"

"అఫ్ కోర్స్! బైట్ అండ్ షార్ట్."

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

ఉదాహరణలు:

int a = 300;

byte a = 100; 

byte a = 300; 

" పొడవాటి రకం గురించి ఏమిటి?"

"మేము మా కోడ్‌లో ఈ రకమైన అక్షరాలను కూడా వ్రాయవచ్చు. దీన్ని చేయడానికి, పూర్ణాంకం చివరిలో '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; 

"ఇది చదవడానికి చాలా సౌకర్యవంతంగా ఉంటుంది, అయితే అండర్ స్కోర్‌కు బదులుగా కామా మరింత సుపరిచితం!"

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

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

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

"రెండూ డబుల్స్ మరియు ఫ్లోట్స్?"

"అవును. వాస్తవానికి, నియమం చాలా సులభం: కోడ్‌లోని ఒక సంఖ్య దశాంశ బిందువును కలిగి ఉంటే, ఆ సంఖ్య ఒక ఫ్లోటింగ్ పాయింట్ అక్షరార్థం. మరియు ఏదైనా అక్షరార్థం కాదు, కానీ డబుల్ లిటరల్. ఫ్లోట్ లిటరల్‌ని సృష్టించడానికి , మీరు సంఖ్య చివరిలో 'F' (లేదా 'f') అక్షరాన్ని ఉంచాలి .

ఉదాహరణలు:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

"మార్గం ద్వారా, మీరు 'F' ( ఫ్లోట్ కోసం ) లేదా D ( రెట్టింపు కోసం ) ప్రత్యయాన్ని జోడించడం ద్వారా పూర్ణాంకం లిటరల్‌ను ఫ్లోట్ లేదా డబుల్ లిటరల్‌గా స్పష్టంగా మార్చవచ్చు . ఉదాహరణలు:

double a = 100D; 

float a = 100F; 

int a = 300D; 

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

స్ట్రింగ్ లిటరల్స్

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

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

"అటువంటి ప్రతి అక్షరం ఒక స్ట్రింగ్ .

ఉదాహరణలు

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

""

"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.";

అక్షర అక్షరాలు

"నాకు స్ట్రింగ్ కాకుండా ఒకే అక్షరం అనే అక్షరార్థం కావాలంటే? నేను ఒకే అక్షరంతో కూడిన స్ట్రింగ్‌ని సృష్టించాలా?"

"కాదు, అలాంటప్పుడు మీకు లిటరల్ కావాల్సింది దీని రకం char. అటువంటి సాహిత్యం యొక్క ప్రారంభం మరియు ముగింపు ఎలా నిర్దేశించబడిందో మీరు ఊహించగలరా?"

"ఒకే కోట్స్?"

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

ఉదాహరణలు:

'A'

'@' 

'本' 

'\u1f3a'

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