జావాలో రీఫ్యాక్టరింగ్ ఎలా పనిచేస్తుంది

మీరు ప్రోగ్రామింగ్ ఎలా చేయాలో నేర్చుకున్నప్పుడు, మీరు కోడ్ రాయడానికి చాలా సమయం వెచ్చిస్తారు. చాలా మంది ప్రారంభ డెవలపర్‌లు భవిష్యత్తులో ఇదే చేస్తారని నమ్ముతారు. ఇది పాక్షికంగా నిజం, కానీ ప్రోగ్రామర్ ఉద్యోగంలో కోడ్‌ను నిర్వహించడం మరియు రీఫ్యాక్టరింగ్ చేయడం కూడా ఉంటుంది. ఈ రోజు మనం రీఫ్యాక్టరింగ్ గురించి మాట్లాడబోతున్నాం.

కోడ్‌జిమ్‌లో రీఫ్యాక్టరింగ్

కోడ్‌జిమ్ కోర్సులో రీఫ్యాక్టరింగ్ రెండుసార్లు కవర్ చేయబడింది:

• మల్టీథ్రెడింగ్ క్వెస్ట్‌లోని 5వ స్థాయిపై పెద్ద టాస్క్
• జావా కలెక్షన్స్ క్వెస్ట్ లెవల్ 9లో IntelliJ IDEAలో రీఫ్యాక్టరింగ్ గురించి ఒక పాఠం.

పెద్ద పని అభ్యాసం ద్వారా నిజమైన రీఫ్యాక్టరింగ్‌తో పరిచయం పొందడానికి అవకాశాన్ని అందిస్తుంది మరియు IDEAలోని రీఫ్యాక్టరింగ్‌పై పాఠం మీ జీవితాన్ని చాలా సులభతరం చేసే స్వయంచాలక సాధనాల్లోకి ప్రవేశించడంలో మీకు సహాయపడుతుంది.

రీఫ్యాక్టరింగ్ అంటే ఏమిటి?

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

    public boolean max(int a, int b) {
        if(a > b) {
            return true;
        } else if (a == b) {
            return false;
        } else {
            return false;
        }
    }

ఇది చాలా విచిత్రమైన కోడ్. ప్రారంభకులకు కూడా ఇలాంటివి చాలా అరుదుగా వ్రాస్తారు, కానీ అవకాశం ఉంది. if-elseమీరు 6-లైన్ పద్ధతిని మరింత సంక్షిప్తంగా వ్రాయగలిగితే బ్లాక్‌ను ఎందుకు ఉపయోగించాలి ?

 public boolean max(int a, int b) {
      return a > b;
 }

ఇప్పుడు మనకు సరళమైన మరియు సొగసైన పద్ధతి ఉంది, అది పై ఉదాహరణ వలె అదే ఆపరేషన్‌ను చేస్తుంది. రీఫ్యాక్టరింగ్ ఈ విధంగా పనిచేస్తుంది: మీరు కోడ్ యొక్క సారాంశాన్ని ప్రభావితం చేయకుండా దాని నిర్మాణాన్ని మారుస్తారు. అనేక రీఫ్యాక్టరింగ్ పద్ధతులు మరియు పద్ధతులు ఉన్నాయి, వీటిని మేము నిశితంగా పరిశీలిస్తాము.

మీకు రీఫ్యాక్టరింగ్ ఎందుకు అవసరం?

అనేక కారణాలున్నాయి. ఉదాహరణకు, కోడ్‌లో సరళత మరియు సంక్షిప్తతను సాధించడానికి. ఈ సిద్ధాంతం యొక్క ప్రతిపాదకులు కోడ్‌ను అర్థం చేసుకోవడానికి అనేక డజన్ల పంక్తుల వ్యాఖ్యలు అవసరం అయినప్పటికీ, సాధ్యమైనంత సంక్షిప్తంగా ఉండాలని నమ్ముతారు. ఇతర డెవలపర్‌లు కోడ్‌ని కనీస సంఖ్యలో కామెంట్‌లతో అర్థమయ్యేలా రీఫ్యాక్టరింగ్ చేయాలని నమ్ముతున్నారు. ప్రతి బృందం దాని స్వంత స్థానాన్ని అవలంబిస్తుంది, కానీ రీఫ్యాక్టరింగ్ అంటే తగ్గింపు కాదని గుర్తుంచుకోండి . కోడ్ యొక్క నిర్మాణాన్ని మెరుగుపరచడం దీని ప్రధాన ఉద్దేశ్యం. ఈ మొత్తం ప్రయోజనంలో అనేక పనులను చేర్చవచ్చు:

1. రీఫ్యాక్టరింగ్ ఇతర డెవలపర్లు వ్రాసిన కోడ్ యొక్క అవగాహనను మెరుగుపరుస్తుంది.
2. ఇది బగ్‌లను కనుగొని పరిష్కరించడంలో సహాయపడుతుంది.
3. ఇది సాఫ్ట్‌వేర్ అభివృద్ధి వేగాన్ని వేగవంతం చేస్తుంది.
4. మొత్తంమీద, ఇది సాఫ్ట్‌వేర్ రూపకల్పనను మెరుగుపరుస్తుంది.

రీఫ్యాక్టరింగ్ చాలా కాలం పాటు నిర్వహించబడకపోతే, అభివృద్ధి పనికి పూర్తి స్టాప్‌తో సహా ఇబ్బందులను ఎదుర్కొంటుంది.

"కోడ్ వాసనలు"

కోడ్‌కు రీఫ్యాక్టరింగ్ అవసరమైనప్పుడు, అది "వాసన" కలిగి ఉంటుందని చెబుతారు. వాస్తవానికి, అక్షరాలా కాదు, కానీ అలాంటి కోడ్ నిజంగా చాలా ఆకర్షణీయంగా కనిపించడం లేదు. దిగువ మేము ప్రారంభ దశ కోసం ప్రాథమిక రీఫ్యాక్టరింగ్ పద్ధతులను అన్వేషిస్తాము.

అసమంజసంగా పెద్ద తరగతులు మరియు పద్ధతులు

తరగతులు మరియు పద్ధతులు గజిబిజిగా ఉంటాయి, వాటి భారీ పరిమాణం కారణంగా సమర్థవంతంగా పని చేయడం అసాధ్యం.

పెద్ద తరగతి

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

సుదీర్ఘ పద్ధతి

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

సుదీర్ఘ పద్ధతిని రీఫ్యాక్టరింగ్ చేయడానికి రెండు నియమాలు ఉన్నాయి:

1. మీరు ఒక పద్ధతిని వ్రాసేటప్పుడు వ్యాఖ్యను జోడించాలని భావిస్తే, మీరు కార్యాచరణను ప్రత్యేక పద్ధతిలో ఉంచాలి.
2. ఒక పద్ధతి 10-15 పంక్తుల కంటే ఎక్కువ కోడ్‌లను తీసుకుంటే, మీరు అది నిర్వర్తించే పనులు మరియు సబ్‌టాస్క్‌లను గుర్తించి, సబ్‌టాస్క్‌లను ప్రత్యేక పద్ధతిలో ఉంచడానికి ప్రయత్నించాలి.

సుదీర్ఘ పద్ధతిని తొలగించడానికి కొన్ని మార్గాలు ఉన్నాయి:

• పద్ధతి యొక్క కార్యాచరణలో కొంత భాగాన్ని ప్రత్యేక పద్ధతికి తరలించండి
• స్థానిక వేరియబుల్స్ మిమ్మల్ని ఫంక్షనాలిటీలో కొంత భాగాన్ని తరలించకుండా నిరోధించినట్లయితే, మీరు మొత్తం వస్తువును మరొక పద్ధతికి తరలించవచ్చు.

చాలా ఆదిమ డేటా రకాలను ఉపయోగించడం

కాలక్రమేణా తరగతిలోని ఫీల్డ్‌ల సంఖ్య పెరిగినప్పుడు ఈ సమస్య సాధారణంగా సంభవిస్తుంది. ఉదాహరణకు, మీరు అన్నింటినీ (కరెన్సీ, తేదీ, ఫోన్ నంబర్లు మొదలైనవి) చిన్న వస్తువులకు బదులుగా ఆదిమ రకాలు లేదా స్థిరాంకాలలో నిల్వ చేస్తే. ఈ సందర్భంలో, ఫీల్డ్‌ల తార్కిక సమూహాన్ని ప్రత్యేక తరగతికి (ఎక్స్‌ట్రాక్ట్ క్లాస్) తరలించడం మంచి పద్ధతి. మీరు డేటాను ప్రాసెస్ చేయడానికి తరగతికి పద్ధతులను కూడా జోడించవచ్చు.

చాలా ఎక్కువ పారామీటర్‌లు ఉన్నాయి

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

డేటా సమూహాలు

తార్కికంగా సంబంధిత డేటా సమూహాలు తరచుగా కోడ్‌లో కనిపిస్తాయి. ఉదాహరణకు, డేటాబేస్ కనెక్షన్ పారామితులు (URL, వినియోగదారు పేరు, పాస్‌వర్డ్, స్కీమా పేరు మొదలైనవి). ఫీల్డ్‌ల జాబితా నుండి ఒక్క ఫీల్డ్‌ను కూడా తీసివేయలేకపోతే, ఈ ఫీల్డ్‌లను ప్రత్యేక తరగతికి (ఎక్స్‌ట్రాక్ట్ క్లాస్) తరలించాలి.

OOP సూత్రాలను ఉల్లంఘించే పరిష్కారాలు

డెవలపర్ సరైన OOP డిజైన్‌ను ఉల్లంఘించినప్పుడు ఈ "వాసనలు" ఏర్పడతాయి. అతను లేదా ఆమె OOP సామర్థ్యాలను పూర్తిగా అర్థం చేసుకోనప్పుడు మరియు వాటిని పూర్తిగా లేదా సరిగ్గా ఉపయోగించడంలో విఫలమైనప్పుడు ఇది జరుగుతుంది.

వారసత్వాన్ని ఉపయోగించడంలో వైఫల్యం

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

ప్రకటన మారండి

ప్రకటనలో తప్పు ఏమిటి switch? ఇది చాలా క్లిష్టంగా మారినప్పుడు ఇది చెడ్డది. సంబంధిత సమస్య పెద్ద సంఖ్యలో సమూహ ifప్రకటనలు.

విభిన్న ఇంటర్‌ఫేస్‌లతో ప్రత్యామ్నాయ తరగతులు

బహుళ తరగతులు ఒకే పనిని చేస్తాయి, కానీ వాటి పద్ధతులు వేర్వేరు పేర్లను కలిగి ఉంటాయి.

తాత్కాలిక క్షేత్రం

ఒక తరగతికి తాత్కాలిక ఫీల్డ్‌ని కలిగి ఉంటే, ఆ వస్తువుకు దాని విలువను సెట్ చేసినప్పుడు అప్పుడప్పుడు మాత్రమే అవసరమవుతుంది మరియు అది ఖాళీగా ఉంటే లేదా, దేవుడు నిషేధించాడని, nullమిగిలిన సమయంలో, కోడ్ వాసన వస్తుంది. ఇది సందేహాస్పదమైన డిజైన్ నిర్ణయం.

సవరణ కష్టతరం చేసే వాసనలు

ఈ వాసనలు మరింత తీవ్రంగా ఉంటాయి. ఇతర వాసనలు ప్రధానంగా కోడ్‌ని అర్థం చేసుకోవడం కష్టతరం చేస్తాయి, అయితే ఇవి మిమ్మల్ని సవరించకుండా నిరోధిస్తాయి. మీరు ఏదైనా కొత్త ఫీచర్‌లను పరిచయం చేయడానికి ప్రయత్నించినప్పుడు, డెవలపర్‌లలో సగం మంది నిష్క్రమించారు మరియు సగం మంది వెర్రితలలు వేస్తున్నారు.

సమాంతర వారసత్వ సోపానక్రమాలు

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

ఏకరీతిగా పంపిణీ చేయబడిన డిపెండెన్సీలు

ఏవైనా సవరణల కోసం మీరు తరగతి యొక్క అన్ని ఉపయోగాలు (డిపెండెన్సీలు) కోసం వెతకాలి మరియు చాలా చిన్న మార్పులు చేయాలి. ఒక మార్పు — అనేక తరగతులలో సవరణలు.

సవరణల సంక్లిష్ట చెట్టు

ఈ వాసన మునుపటి దానికి విరుద్ధంగా ఉంటుంది: మార్పులు ఒక తరగతిలోని పెద్ద సంఖ్యలో పద్ధతులను ప్రభావితం చేస్తాయి. నియమం ప్రకారం, అటువంటి కోడ్ క్యాస్కేడింగ్ డిపెండెన్సీని కలిగి ఉంటుంది: ఒక పద్ధతిని మార్చడం వలన మీరు మరొకదానిలో ఏదైనా సరిదిద్దాలి, ఆపై మూడవది మరియు మొదలైనవి. ఒక తరగతి - అనేక మార్పులు.

"చెత్త వాసన"

తలనొప్పికి కారణమయ్యే వాసనల యొక్క అసహ్యకరమైన వర్గం. పనికిరాని, అనవసరమైన, పాత కోడ్. అదృష్టవశాత్తూ, ఆధునిక IDEలు మరియు లిన్టర్‌లు అలాంటి వాసనల గురించి హెచ్చరించడం నేర్చుకున్నాయి.

ఒక పద్ధతిలో పెద్ద సంఖ్యలో వ్యాఖ్యలు

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

నకిలీ కోడ్

విభిన్న తరగతులు లేదా పద్ధతులు ఒకే కోడ్ బ్లాక్‌లను ఉపయోగిస్తాయి.

సోమరితనం తరగతి

ఒక తరగతి చాలా తక్కువ కార్యాచరణను తీసుకుంటుంది, అయితే ఇది పెద్దదిగా ఉండాలని ప్రణాళిక చేయబడింది.

ఉపయోగించని కోడ్

కోడ్‌లో క్లాస్, మెథడ్ లేదా వేరియబుల్ ఉపయోగించబడదు మరియు డెడ్ వెయిట్ ఉంటుంది.

అధిక కనెక్టివిటీ

ఈ వర్గం వాసనలు కోడ్‌లో పెద్ద సంఖ్యలో అన్యాయమైన సంబంధాల ద్వారా వర్గీకరించబడతాయి.

బాహ్య పద్ధతులు

ఒక పద్ధతి దాని స్వంత డేటా కంటే చాలా తరచుగా మరొక వస్తువు నుండి డేటాను ఉపయోగిస్తుంది.

తగని సాన్నిహిత్యం

ఒక తరగతి మరొక తరగతి అమలు వివరాలపై ఆధారపడి ఉంటుంది.

లాంగ్ క్లాస్ కాల్స్

ఒక తరగతి మరొకరికి కాల్ చేస్తుంది, ఇది మూడవ వంతు నుండి డేటాను అభ్యర్థిస్తుంది, ఇది నాల్గవ నుండి డేటాను పొందుతుంది మరియు మొదలైనవి. అటువంటి పొడవైన కాల్‌ల గొలుసు అంటే ప్రస్తుత తరగతి నిర్మాణంపై అధిక ఆధారపడటం.

టాస్క్-డీలర్ క్లాస్

ఒక పనిని మరొక తరగతికి పంపడానికి మాత్రమే తరగతి అవసరం. బహుశా అది తీసివేయబడాలా?

రీఫ్యాక్టరింగ్ పద్ధతులు

వివరించిన కోడ్ వాసనలను తొలగించడంలో సహాయపడే ప్రాథమిక రీఫ్యాక్టరింగ్ పద్ధతులను మేము క్రింద చర్చిస్తాము.

తరగతిని సంగ్రహించండి

ఒక తరగతి చాలా విధులు నిర్వహిస్తుంది. వాటిలో కొన్నింటిని వేరే తరగతికి తరలించాలి. ఉదాహరణకు, మేము Humanఇంటి చిరునామాను నిల్వ చేసే తరగతిని కలిగి ఉన్నామని మరియు పూర్తి చిరునామాను అందించే పద్ధతిని కలిగి ఉన్నారని అనుకుందాం:

class Human {
    private String name;
    private String age;
    private String country;
    private String city;
    private String street;
    private String house;
    private String quarter;
 
    public String getFullAddress() {
        StringBuilder result = new StringBuilder();
        return result
                        .append(country)
                        .append(", ")
                        .append(city)
                        .append(", ")
                        .append(street)
                        .append(", ")
                        .append(house)
                        .append(" ")
                        .append(quarter).toString();
    }
 }

చిరునామా సమాచారం మరియు అనుబంధిత పద్ధతిని (డేటా ప్రాసెసింగ్ ప్రవర్తన) ప్రత్యేక తరగతిలో ఉంచడం మంచి పద్ధతి:

 class Human {
    private String name;
    private String age;
    private Address address;
 
    private String getFullAddress() {
        return address.getFullAddress();
    }
 }
 class Address {
    private String country;
    private String city;
    private String street;
    private String house;
    private String quarter;
 
    public String getFullAddress() {
        StringBuilder result = new StringBuilder();
        return result
                        .append(country)
                        .append(", ")
                        .append(city)
                        .append(", ")
                        .append(street)
                        .append(", ")
                        .append(house)
                        .append(" ")
                        .append(quarter).toString();
    }
 }

ఒక పద్ధతిని సంగ్రహించండి

ఒక పద్ధతికి కొన్ని కార్యాచరణలు ఉంటే అది వేరు చేయగలిగితే, మీరు దానిని ప్రత్యేక పద్ధతిలో ఉంచాలి. ఉదాహరణకు, వర్గ సమీకరణం యొక్క మూలాలను లెక్కించే పద్ధతి:

    public void calcQuadraticEq(double a, double b, double c) {
        double D = b * b - 4 * a * c;
        if (D > 0) {
            double x1, x2;
            x1 = (-b - Math.sqrt(D)) / (2 * a);
            x2 = (-b + Math.sqrt(D)) / (2 * a);
            System.out.println("x1 = " + x1 + ", x2 = " + x2);
        }
        else if (D == 0) {
            double x;
            x = -b / (2 * a);
            System.out.println("x = " + x);
        }
        else {
            System.out.println("Equation has no roots");
        }
    }

మేము మూడు సాధ్యమైన ఎంపికలలో ప్రతిదాన్ని వేర్వేరు పద్ధతుల్లో లెక్కిస్తాము:

    public void calcQuadraticEq(double a, double b, double c) {
        double D = b * b - 4 * a * c;
        if (D > 0) {
            dGreaterThanZero(a, b, D);
        }
        else if (D == 0) {
            dEqualsZero(a, b);
        }
        else {
            dLessThanZero();
        }
    }
 
    public void dGreaterThanZero(double a, double b, double D) {
        double x1, x2;
        x1 = (-b - Math.sqrt(D)) / (2 * a);
        x2 = (-b + Math.sqrt(D)) / (2 * a);
        System.out.println("x1 = " + x1 + ", x2 = " + x2);
    }
 
    public void dEqualsZero(double a, double b) {
        double x;
        x = -b / (2 * a);
        System.out.println("x = " + x);
    }
 
    public void dLessThanZero() {
        System.out.println("Equation has no roots");
    }

ప్రతి పద్ధతి యొక్క కోడ్ చాలా చిన్నదిగా మరియు అర్థం చేసుకోవడానికి సులభంగా మారింది.

మొత్తం వస్తువును దాటడం

పారామితులతో పద్ధతిని పిలిచినప్పుడు, మీరు కొన్నిసార్లు ఇలాంటి కోడ్‌ని చూడవచ్చు:

 public void employeeMethod(Employee employee) {
     // Some actions
     double yearlySalary = employee.getYearlySalary();
     double awards = employee.getAwards();
     double monthlySalary = getMonthlySalary(yearlySalary, awards);
     // Continue processing
 }
 
 public double getMonthlySalary(double yearlySalary, double awards) {
      return (yearlySalary + awards)/12;
 }

employeeMethodవిలువలను స్వీకరించడానికి మరియు వాటిని ఆదిమ వేరియబుల్స్‌లో నిల్వ చేయడానికి 2 మొత్తం లైన్‌లను కలిగి ఉంది . కొన్నిసార్లు ఇటువంటి నిర్మాణాలు 10 లైన్ల వరకు పట్టవచ్చు. వస్తువును స్వయంగా పాస్ చేయడం మరియు అవసరమైన డేటాను సేకరించేందుకు దాన్ని ఉపయోగించడం చాలా సులభం:

 public void employeeMethod(Employee employee) {
     // Some actions
     double monthlySalary = getMonthlySalary(employee);
     // Continue processing
 }
 
 public double getMonthlySalary(Employee employee) {
     return (employee.getYearlySalary() + employee.getAwards())/12;
 }

సరళమైనది, సంక్షిప్తమైనది మరియు సంక్షిప్తమైనది.

ఫీల్డ్‌లను తార్కికంగా సమూహపరచడం మరియు వాటిని వేరుగా తరలించడం classDespiteవలన పైన ఉన్న ఉదాహరణలు చాలా సరళమైనవి మరియు మీరు వాటిని చూసినప్పుడు, "ఎవరు ఇలా చేస్తారు?" అని మీలో చాలామంది అడగవచ్చు, చాలా మంది డెవలపర్‌లు అజాగ్రత్త కారణంగా ఇటువంటి నిర్మాణాత్మక లోపాలను చేస్తారు, కోడ్‌ను రీఫాక్టర్ చేయడానికి ఇష్టపడకపోవడం లేదా "అది సరిపోతుంది" అనే వైఖరి.

రీఫ్యాక్టరింగ్ ఎందుకు ప్రభావవంతంగా ఉంటుంది

మంచి రీఫ్యాక్టరింగ్ ఫలితంగా, ప్రోగ్రామ్‌లో సులభంగా చదవగలిగే కోడ్ ఉంటుంది, దాని లాజిక్‌ను మార్చే అవకాశం భయపెట్టదు మరియు కొత్త ఫీచర్‌లను పరిచయం చేయడం కోడ్ విశ్లేషణ నరకం కాదు, బదులుగా రెండు రోజుల పాటు ఆహ్లాదకరమైన అనుభవం. . మొదటి నుండి ప్రోగ్రామ్‌ను వ్రాయడం సులభమైతే మీరు రీఫాక్టర్ చేయకూడదు. ఉదాహరణకు, మొదటి నుండి అదే ఫంక్షనాలిటీని అమలు చేయడం కంటే కోడ్‌ను అర్థం చేసుకోవడానికి, విశ్లేషించడానికి మరియు రీఫాక్టర్ చేయడానికి అవసరమైన శ్రమ ఎక్కువగా ఉంటుందని మీ బృందం అంచనా వేసింది. లేదా రీఫ్యాక్టర్ చేయాల్సిన కోడ్‌లో చాలా సమస్యలు ఉంటే, వాటిని డీబగ్ చేయడం కష్టం. ప్రోగ్రామర్ పనిలో కోడ్ యొక్క నిర్మాణాన్ని ఎలా మెరుగుపరచాలో తెలుసుకోవడం చాలా అవసరం. మరియు జావాలో ప్రోగ్రామ్ చేయడం నేర్చుకోవడం కోడ్‌జిమ్‌లో ఉత్తమంగా చేయబడుతుంది, ఇది అభ్యాసాన్ని నొక్కి చెప్పే ఆన్‌లైన్ కోర్సు. తక్షణ ధృవీకరణతో 1200+ టాస్క్‌లు, దాదాపు 20 చిన్న-ప్రాజెక్ట్‌లు, గేమ్ టాస్క్‌లు - ఇవన్నీ మీకు కోడింగ్‌లో నమ్మకంగా ఉండటానికి సహాయపడతాయి. ప్రారంభించడానికి ఉత్తమ సమయం ఇప్పుడు :)

రీఫ్యాక్టరింగ్‌లో మిమ్మల్ని మీరు మరింతగా లీనం చేసుకునేందుకు వనరులు

రీఫ్యాక్టరింగ్ గురించిన అత్యంత ప్రసిద్ధ పుస్తకం మార్టిన్ ఫౌలర్ రచించిన "రీఫ్యాక్టరింగ్. ఇంప్రూవింగ్ ది డిజైన్ ఆఫ్ ఎగ్జిస్టింగ్ కోడ్". మునుపటి పుస్తకం ఆధారంగా రీఫ్యాక్టరింగ్ గురించి ఆసక్తికరమైన ప్రచురణ కూడా ఉంది: జాషువా కెరివ్‌స్కీ రాసిన "రీఫ్యాక్టరింగ్ యూజింగ్ ప్యాటర్న్స్". నమూనాల గురించి మాట్లాడుతూ... రీఫ్యాక్టరింగ్ చేసేటప్పుడు, ప్రాథమిక డిజైన్ నమూనాలను తెలుసుకోవడం ఎల్లప్పుడూ చాలా ఉపయోగకరంగా ఉంటుంది. ఈ అద్భుతమైన పుస్తకాలు దీనికి సహాయపడతాయి: నమూనాల గురించి మాట్లాడుతూ... రీఫ్యాక్టరింగ్ చేసేటప్పుడు, ప్రాథమిక డిజైన్ నమూనాలను తెలుసుకోవడం ఎల్లప్పుడూ చాలా ఉపయోగకరంగా ఉంటుంది. ఈ అద్భుతమైన పుస్తకాలు దీనికి సహాయపడతాయి:

1. హెడ్ ​​ఫస్ట్ సిరీస్ నుండి ఎరిక్ ఫ్రీమాన్, ఎలిజబెత్ రాబ్సన్, కాథీ సియెర్రా మరియు బెర్ట్ బేట్స్ రూపొందించిన "డిజైన్ ప్యాటర్న్స్"
2. డస్టిన్ బోస్వెల్ మరియు ట్రెవర్ ఫౌచర్ ద్వారా "ది ఆర్ట్ ఆఫ్ రీడబుల్ కోడ్"
3. స్టీవ్ మెక్‌కాన్నెల్ ద్వారా "కోడ్ కంప్లీట్", ఇది అందమైన మరియు సొగసైన కోడ్ కోసం సూత్రాలను నిర్దేశిస్తుంది.