జావా కంపైలర్ ద్వారా అనుమితిని టైప్ చేయండి

1. వాక్యనిర్మాణ చక్కెర

కొన్ని క్లిష్టమైన కోడ్ లేదా లాజిక్‌లను రెండు పంక్తులలో వ్రాయగలిగినప్పుడు, కోడ్‌ని కాంపాక్ట్‌గా మరియు చదవగలిగేలా చేయడం ప్రోగ్రామర్లు ఇష్టపడతారు. మరియు ప్రోగ్రామింగ్ భాషల సృష్టికర్తలు కొన్నిసార్లు దీనికి సహాయం చేస్తారు.

సత్వరమార్గాన్ని (తక్కువ కోడ్ వ్రాయండి) తీసుకోవడానికి మిమ్మల్ని అనుమతించే వివేక భాషా లక్షణాన్ని వాక్యనిర్మాణ చక్కెర అంటారు . కానీ, నిజం చెప్పాలంటే, జావాలో ఇది చాలా తక్కువ.

జావా సృష్టికర్తలు జావాలో ఏదైనా రిడెండెన్సీని తొలగించడానికి వారు చేయగలిగినదంతా చేశారు. C++ మిమ్మల్ని 20 విధాలుగా చేయడానికి అనుమతిస్తే, జావా మిమ్మల్ని ఒకే మార్గంలో అనుమతిస్తుంది.

కానీ జావా ప్రోగ్రామర్లు లేదా జావా సృష్టికర్తలు స్వేచ్ఛ లేకపోవడాన్ని ఇష్టపడలేదు. మరియు కొన్నిసార్లు చక్కెర మీ మరియు నా వంటి సాధారణ వ్యక్తులకు జీవితాన్ని సులభతరం చేస్తుంది.

మార్గం ద్వారా, మీరు ఇప్పటికే కొన్ని వాక్యనిర్మాణ చక్కెరను ఎదుర్కొన్నారు: ఆటోబాక్సింగ్ మరియు అన్‌బాక్సింగ్ . పోల్చి చూద్దాం:

Integer a = new Integer(5);
int b = a.intValue();

Integer a = 5;
int b = a;

int b = 5;
Integer c = new Integer(b);

int b = 5;
Integer c = b;

Integer a = new Integer(1);
int b = 1;
if (a.intValue() == b)
{
   ...
}

Integer a = 1;
int b = 1;
if (a == b)
{
   ...
}

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

2. వేరియబుల్ రకం యొక్క అనుమితి: varకీవర్డ్

జావా 11లో, కంపైలర్ మరింత తెలివిగా మారింది మరియు ఇప్పుడు దానికి కేటాయించిన విలువ రకం ఆధారంగా డిక్లేర్డ్ వేరియబుల్ రకాన్ని నిర్ణయించవచ్చు . కోడ్‌లో, ఇది ఇలా కనిపిస్తుంది:

var name = value;

nameకొత్త వేరియబుల్ పేరు ఎక్కడ ఉంది, విలువ అనేది దాని ప్రారంభ విలువ మరియు varవేరియబుల్‌ను ప్రకటించడానికి ఉపయోగించే కీవర్డ్. పేరు వేరియబుల్ రకం దానికి కేటాయించిన విలువ రకం వలె ఉంటుంది.

ఉదాహరణలు:

var i = 1;

int i = 1;

var s = "Hello";

String s = "Hello";

var console = new Scanner(System.in);

Scanner console = new Scanner(System.in);

var list = new ArrayList<String>();

ArrayList<String> list = new ArrayList<String>();

var data = new int[]{1, 2, 3};

int[] data = new int[]{1, 2, 3};

కంపైలర్ దానికి కేటాయించిన విలువ ఆధారంగా వేరియబుల్ రకాన్ని నిర్ణయిస్తుంది లేదా అంచనా వేస్తుంది.

భాషకు అటువంటి లక్షణాన్ని జోడించాలా వద్దా అనే దానిపై ప్రోగ్రామర్లు తీవ్రంగా చర్చించారు. చాలా మంది అది varదుర్వినియోగం చేయబడుతుందని మరియు దాని ఫలితంగా కోడ్ రీడబిలిటీ దెబ్బతింటుందని భయపడ్డారు.

దీనికి కొంత నిజం ఉంది, కాబట్టి ఇది varకోడ్ యొక్క రీడబిలిటీని పెంచే చోట ఉపయోగించడం ఉత్తమం. ఉదాహరణకు, ఇవి రెండు సందర్భాలలో:

కేస్ 1: వేరియబుల్‌కు కేటాయించిన విలువను చూస్తే, వేరియబుల్ రకం వెంటనే స్పష్టంగా కనిపిస్తుంది

var stream = url.getInputStream();

var name = person.getFullName();

ఈ సందర్భాలలో, మీరు ఉపయోగించకూడదుvar . సరే, వేరియబుల్ రకం ఏమిటి?

var result = task.execute();

var status = person.getStatus();

కేస్ 2: కోడ్‌ని అర్థం చేసుకోవడానికి వేరియబుల్ రకం ముఖ్యం కాదు

కోడ్‌కు తరచుగా వేరియబుల్‌పై పద్ధతులను కాల్ చేయాల్సిన అవసరం ఉండదు, ఉదా. వేరియబుల్‌ను తాత్కాలికంగా నిల్వ చేయడానికి ఉపయోగించినప్పుడు. ఈ సందర్భంలో, ఉపయోగించడం varఖచ్చితంగా కోడ్ యొక్క రీడబిలిటీని తగ్గించదు:

var data = stream.getMetaData();
storage.save(data)

బంగారు సగటు

ఇప్పుడు నేను ఒకే కోడ్‌ని వ్రాయడానికి మూడు మార్గాలు ఇస్తాను. ఉపయోగించడం varఉత్తమ ఎంపిక.

dest.writeHeaderInfo(src.getFileMetaInfo());

var headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

FileMetaInfo headerInfo = src.getFileMetaInfo();
dest.writeHeaderInfo(headerInfo);

1 లైన్‌తో వెర్షన్ నుండి 2 లైన్‌లలోని వెర్షన్‌కి తరలించడం, మేము వేరియబుల్ పేరు ( )ని ఉపయోగించడం ద్వారా కోడ్‌ని కొంచెం చదవగలిగేలా చేసాము headerInfo. ఈ పద్ధతి మెటా సమాచారాన్ని మాత్రమే కాకుండా, హెడర్ సమాచారాన్ని అందిస్తుంది అని ఇప్పుడు స్పష్టమైంది.

మూడవ వెర్షన్ అతి పదజాలం. headerInfoఅనే వాస్తవం FileMetaInfoఇప్పటికే getFileMetaInfo()పద్ధతి నుండి చాలా స్పష్టంగా ఉంది. మెటా సమాచారం యొక్క ప్రయోజనం మరింత ఆసక్తికరంగా ఉంటుంది.

3. డైమండ్ ఆపరేటర్‌తో రకాన్ని వదిలివేయడం:<>

ఆపరేటర్ కనిపించక ముందే var, సేకరణ రకాలను ఎలా ఊహించాలో కంపైలర్‌కు బోధించే ప్రయత్నాలు జరిగాయి. ఈ సంజ్ఞామానం కొద్దిగా అనవసరంగా ఉందని మీరు అంగీకరిస్తారు:

ArrayList<String> list = new ArrayList<String>();

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

ArrayList<String> list = new ArrayList<>();

మీరు చూడగలిగినట్లుగా, మీరు ఇకపై స్ట్రింగ్‌ను రెండవసారి వ్రాయవలసిన అవసరం లేదు. var ఆపరేటర్‌తో వలె కూల్‌గా లేదు, కానీ అది ఆ సమయంలో పురోగతిలా అనిపించింది.

సేకరణ రకంలోని ఖాళీ యాంగిల్ బ్రాకెట్‌లను డైమండ్ ఆపరేటర్ అని పిలుస్తారు , ఎందుకంటే రెండు కోణ బ్రాకెట్‌లు అస్పష్టంగా డైమండ్‌ను పోలి ఉంటాయి.

varకీవర్డ్ మరియు డైమండ్ ఆపరేటర్‌ని ఒకే సమయంలో ఉపయోగించడం అవాంఛనీయమైనది :

var list = new ArrayList<>();

సేకరణలో నిల్వ చేయబడిన మూలకాల రకం గురించి ఎటువంటి సమాచారం లేదు మరియు సేకరణ రకం అర్రేలిస్ట్ < ఆబ్జెక్ట్ > అవుతుంది.

4. డబుల్ కర్లీ జంట కలుపులు

త్వరిత శ్రేణి ప్రారంభించడం గుర్తుందా?

మేము ఇప్పుడే ఇలా కర్లీ బ్రేస్‌లలో విలువలను జాబితా చేసాము:

int[] data = new int[] {1, 2, 3, 4, 5, 6, 7};

int[] data = {1, 2, 3, 4, 5, 6, 7};

జావా సృష్టికర్తలు శ్రేణి యొక్క వ్రాత అంశాలను సులభతరం చేయడానికి కర్లీ బ్రేస్‌లను ఉపయోగించాలనే ఆలోచనను ఇష్టపడ్డారు. అయితే కలెక్షన్ల సంగతేంటి?

జావా సృష్టికర్తలు సేకరణల కోసం తగినంత సృజనాత్మక ఆలోచనను కలిగి ఉన్నారు, డబుల్ కర్లీ బ్రేస్‌లతో ఒక ట్రిక్‌ను ఉపయోగించేందుకు వారిని అనుమతించారు.

var list = new ArrayList<String>()
{{
   add("Hello");
   add("How's");
   add("Life?");
}};

var list = new ArrayList<String>();

list.add("Hello");
list.add("How's");
list.add("Life?");

కంపైలర్ ఎడమ వైపున ఉన్న ఉదాహరణలో కోడ్‌ను ఎదుర్కొంటే, అది దానిని కుడి వైపున ఉన్న కోడ్‌గా మారుస్తుంది.

కోడ్ చాలా కాంపాక్ట్‌గా మారదు. ఇక్కడ పొదుపులు చాలా తక్కువగా ఉన్నాయి: మీరు listప్రతిసారీ వ్రాయవలసిన అవసరం లేదు. వేరియబుల్ పేరు చాలా పొడవుగా ఉంటే ఇది సహాయపడుతుంది.

కానీ మీరు ప్రాజెక్ట్‌లో ఇలాంటి కోడ్‌ని చూసినట్లయితే, ఆశ్చర్యపోకండి 🙂