IDEA: రీఫ్యాక్టరింగ్

"మళ్ళీ హలో."

"హాయ్!"

"ఈరోజు నేను మీకు రీఫ్యాక్టరింగ్ గురించి చెప్పబోతున్నాను. రీఫ్యాక్టరింగ్ అనేది ప్రాజెక్ట్‌లోని కోడ్‌ని దాని కార్యాచరణను మార్చకుండా మార్చడం."

"అయితే అది ఎలా సాధ్యం?"

"సరే, సరళమైన సందర్భాల్లో, మేము వేరియబుల్స్ మరియు/లేదా పద్ధతులను పేరు మార్చవచ్చు. అన్నింటికంటే, వేరియబుల్ పేరును మార్చడం ప్రోగ్రామ్ భిన్నంగా పని చేయదు, అవునా?"

"అస్సలు కానే కాదు."

"మీరు పెద్ద పద్ధతులను అనేక చిన్నవిగా విభజించవచ్చు. "

"మీరు పునరావృతమయ్యే కోడ్ స్నిప్పెట్‌లను ప్రత్యేక పద్ధతిలోకి లాగవచ్చు. "

"కొన్ని ఫంక్షన్‌లు స్టాటిక్‌గా ప్రకటించబడతాయి మరియు తర్వాత యుటిలిటీ తరగతులకు తరలించబడతాయి."

"కానీ ఇది రీఫ్యాక్టరింగ్ యొక్క ఇరుకైన వివరణ."

"రీఫ్యాక్టరింగ్ అంటే కొన్నిసార్లు కొత్త కార్యాచరణను జోడించకుండా ప్రాజెక్ట్ యొక్క నిర్మాణాన్ని తిరిగి వ్రాయడం (మెరుగుపరచడం) అని అర్థం. ఇది పదం యొక్క విస్తృత అర్థంలో రీఫ్యాక్టరింగ్."

"IntelliJ IDEA అత్యంత ప్రజాదరణ పొందిన ఇంటిగ్రేటెడ్ డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్ (IDE)గా మారింది, ఎందుకంటే ఇది చాలా శక్తివంతమైన రీఫ్యాక్టరింగ్ సాధనాలను ప్రవేశపెట్టిన మొదటిది."

"ఈ మంత్ర సాధనాలు ఏమిటి?"

మ్యాజిక్ ట్రిక్ #1: పద్ధతి పేరు మార్చండి.

"మీ కోడ్ 100-500 వేర్వేరు ప్రదేశాల నుండి పిలవబడే పద్ధతిని కలిగి ఉందని ఊహించండి. మీరు దాని పేరును మరింత అర్థమయ్యేలా మార్చాలని నిర్ణయించుకున్నారు. ఇది రన్(), మరియు మీరు దీన్ని runDownloadTaskAsync() అని అనుకుందాం. ఎంత త్వరగా నువ్వు అది చేయగలవా?"

"సరే, మొదట మీరు పద్ధతి పేరుని మార్చాలి, ఆపై ప్రోగ్రామ్‌లో ఆ పద్ధతిని పిలిచే అన్ని స్థలాలను కనుగొని, అక్కడ పేరును కూడా మార్చాలి."

"మరియు మీరు ఆ స్థలాలను ఎలా కనుగొంటారు?"

"నేను ప్రోగ్రామ్‌ను అమలు చేస్తాను మరియు IntelliJ IDEA నాకు ఉనికిలో లేని పద్ధతి అని పిలువబడే అన్ని స్థలాలను చూపుతుంది."

"సరే. కానీ ఇప్పుడు ప్రతి పద్ధతికి వివరణాత్మక వ్యాఖ్య (జావాడాక్) ఉందని అనుకుందాం, అది పద్ధతి ఏమి చేస్తుందో వివరిస్తుంది - మరియు పాత పద్ధతి పేరు అక్కడ వ్రాయబడింది."

"నేను వ్యాఖ్యలను కూడా మారుస్తాను."

"కానీ పద్ధతి పేరుతో అనుబంధించబడిన వేరియబుల్స్ కూడా ఉండవచ్చు. వాటిని కూడా మార్చడం మంచిది:"

Task task = manager.run();

Task asyncTask = manager.runDownloadTaskAsync();

"అవును, ఆ వేరియబుల్స్ పేర్లు కూడా మార్చితే బాగుంటుంది. బాధ పడదు."

"సరే, ఇవన్నీ IntelliJ IDEAని ఉపయోగించి కొన్ని సెకన్లలో పూర్తి చేయవచ్చు!"

"మీరు పద్ధతి పేరుపై కర్సర్‌ను ఉంచండి (లేదా దాన్ని మౌస్‌తో క్లిక్ చేయండి), ఆపై Shift+F6 నొక్కండి మరియు కావలసిన పద్ధతి పేరును టైప్ చేయడం ప్రారంభించండి."

"పద్ధతి పేరును సవరించడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది."

"సవరణ ప్రారంభించు:"

"కొత్త పేరును పేర్కొనండి:"

"కొత్త పేరును నమోదు చేయండి, ఎంటర్ నొక్కండి మరియు అంతే. ఈ పద్ధతిని ప్రాజెక్ట్‌లో పిలిచే ప్రతిచోటా పేరు మార్చబడుతుంది."

"IntelliJ IDEA సాధారణంగా మీరు వ్యాఖ్యలలో వేరియబుల్ పేర్లు మరియు పద్ధతి పేర్లను మార్చాలనుకుంటున్నారా అని అడుగుతుంది. కేవలం 'అవును' క్లిక్ చేయండి మరియు అది ప్రతిదీ మారుస్తుంది."

"ఇంకా ఏమిటంటే, ఈ రీఫ్యాక్టరింగ్ ఆపరేషన్‌కు ముందు ప్రాజెక్ట్ కంపైల్ చేయబడి ఉంటే, అది రీఫ్యాక్టరింగ్ తర్వాత కంపైల్ చేయడానికి హామీ ఇవ్వబడుతుంది."

"చాలా ఆశాజనకంగా ఉంది."

"మార్గం ద్వారా, మీరు వేరియబుల్ పేర్లను అదే విధంగా మార్చవచ్చు. పేరును క్లిక్ చేసిన తర్వాత, Shift+F6 నొక్కండి — మీరు కొత్త పేరును నమోదు చేయవచ్చు మరియు IntelliJ వేరియబుల్ పేరును ఎక్కడ ఉపయోగించినా మారుస్తుంది. "

"వేరియబుల్ అనేది క్లాస్‌లోని ఫీల్డ్ మరియు గెట్టర్ మరియు సెట్టర్‌ను కలిగి ఉన్నట్లయితే, వేరియబుల్ యొక్క కొత్త పేరుకు సరిపోయేలా గెటర్ మరియు సెట్టర్ పేర్లు కూడా మార్చబడతాయి."

"నేను వేరియబుల్స్ ఉపయోగించి దీనిని ప్రయత్నించాను. మీరు చెప్పినట్లే అంతా పని చేస్తుంది, ఎల్లీ. రీఫ్యాక్టరింగ్ అద్భుతం!"

"రీఫ్యాక్టరింగ్ చేయాలంటే అంతే అని మీరు అనుకుంటున్నారా? రిఫ్రాక్టరింగ్ అనేది చాలా విస్తృతమైన అంశం — మేము ఉపరితలంపై కూడా గీతలు పడలేదు."

"అయ్యో. ఇంకా ఏముంది?"

మ్యాజిక్ ట్రిక్ #2: వేరియబుల్‌ని సంగ్రహించండి.

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

public void printInfo(User user)
{
 System.out.println(user.getProfile().getName());
 System.out.println(user.getProfile().getAddress().getState());
 System.out.println(user.getProfile().getAddress().getCity());
 System.out.println(user.getProfile().getAddress().getStreet());
 System.out.println(user.getProfile().getAddress().getHomeNumber());
}

public void printInfo(User user)
{
 Address address = user.getProfile().getAddress();

 System.out.println(user.getProfile().getName());
 System.out.println(address.getState());
 System.out.println(address.getCity());
 System.out.println(address.getStreet());
 System.out.println(address.getHomeNumber());
}

"ఆహ్."

"మరియు కోడ్ చాలా క్లిష్టంగా ఉంటుంది, చాలా పునరావృత భాగాలతో ఉంటుంది."

"ప్రోగ్రామర్లు ఉద్దేశపూర్వకంగా ఆ విధంగా వ్రాయరు. కానీ మీరు తరచుగా ఒక పద్ధతికి ఏదైనా జోడించవలసి ఉంటుంది, తర్వాత ఇంకేదైనా ఉంటుంది - మరియు కాలక్రమేణా పునరావృతాల సంఖ్య పైకప్పు గుండా వెళుతుంది."

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

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

"అవును, నేను అంగీకరిస్తున్నాను. అటువంటి వేరియబుల్స్ జోడించడం అర్ధమే."

"కాబట్టి, మీరు దీన్ని ఎలా చేస్తారు?"

"వ్యక్తీకరణను ప్రత్యేక వేరియబుల్‌లోకి తరలించడం చాలా సులభం."

దశ 1: వ్యక్తీకరణను ఎంచుకోవడానికి మౌస్ ఉపయోగించండి.

దశ 2: Ctrl+Alt+V నొక్కండి

"మేము ఎంచుకున్న వ్యక్తీకరణను మాత్రమే భర్తీ చేయాలనుకుంటున్నారా లేదా వ్యక్తీకరణ యొక్క అన్ని సందర్భాలను (4 సంఘటనలు) భర్తీ చేయాలనుకుంటున్నారా అని IntelliJ IDEA అడుగుతున్న చోట ఒక విండో తెరుచుకుంటుంది?"

"అన్ని సంఘటనలను భర్తీ చేయడానికి రెండవ ఎంపికను ఎంచుకోండి (మొత్తం 4 సంఘటనలను భర్తీ చేయండి)"

దశ 3: ఎంటర్ నొక్కండి.

"IntelliJ IDEA వేరియబుల్ పేరును నమోదు చేయమని మిమ్మల్ని అడుగుతుంది. ఇది పేరు కోసం దాని స్వంత సూచనను కూడా చేస్తుంది. చెడ్డది కాదు, ఇహ్?"

"ఉహూ. సరిగ్గానే. వేరియబుల్‌కి 'అడ్రస్' అని పేరు పెట్టాలని కూడా ప్లాన్ చేస్తున్నాం. అది ఎలా తెలిసింది?"

"ఎక్స్‌ప్రెషన్‌లోని చివరి పద్ధతి పేరును ఉపయోగించడం ద్వారా, ఇది చిరునామాను అందిస్తుంది. అందువల్ల, చిరునామాను నిల్వ చేయడానికి వేరియబుల్ ఉపయోగించబడే అవకాశం ఉంది."

"అది చాలా బాగా పనిచేసింది. గ్రేట్ స్టఫ్, ఎల్లీ."

మ్యాజిక్ ట్రిక్ #3: కోడ్‌ని ప్రత్యేక పద్ధతిలో సంగ్రహించండి.

"అయితే మనం ఇంకేదైనా చేసి ఉండవచ్చు. మేము ఒక కొత్త పద్ధతిని ప్రకటించి ఉండవచ్చు, ఉదా. printAddress (), మరియు ఈ కోడ్ మొత్తాన్ని దానిలోకి తరలించవచ్చు."

"అలా చేయడానికి ప్రయత్నిద్దాం."

దశ 1: చిరునామా వేరియబుల్‌ని ఉపయోగించే 4 లైన్‌ల కోడ్‌లను ఎంచుకోండి:

దశ 2: Ctrl+Alt+M నొక్కండి

"IntelliJ IDEA పద్ధతికి ఏ వేరియబుల్స్ అవసరమో నిర్ణయిస్తుంది మరియు అది ఎలా ఉండాలో సూచిస్తుంది. "పద్ధతి కోసం పేరును నమోదు చేయడం మాత్రమే మిగిలి ఉంది."

దశ 3: ప్రింట్ అడ్రస్‌ను పద్ధతి పేరుగా నమోదు చేసి, ఎంటర్ నొక్కండి.

"మీకు అది ఎలా ఇష్టం?"

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