ஜாவாவில் மறுசீரமைப்பு எவ்வாறு செயல்படுகிறது

நிரலாக்கம் செய்வது எப்படி என்பதை நீங்கள் கற்றுக் கொள்ளும்போது, ​​குறியீட்டை எழுதுவதற்கு அதிக நேரம் செலவிடுகிறீர்கள். பெரும்பாலான ஆரம்ப டெவலப்பர்கள் எதிர்காலத்தில் இதைத்தான் செய்வார்கள் என்று நம்புகிறார்கள். இது ஓரளவு உண்மைதான், ஆனால் ஒரு புரோகிராமரின் வேலையில் குறியீட்டைப் பராமரித்தல் மற்றும் மறுசீரமைத்தல் ஆகியவை அடங்கும். இன்று நாம் மறுசீரமைப்பு பற்றி பேசுவோம்.

கோட்ஜிம்மில் மறுசீரமைப்பு

கோட்ஜிம் பாடத்தில் மறுசீரமைப்பு இரண்டு முறை உள்ளடக்கப்பட்டுள்ளது:

• மல்டித்ரெடிங் தேடலின் நிலை 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-else6-வரி முறையை இன்னும் சுருக்கமாக எழுத முடிந்தால், ஏன் ஒரு தொகுதியைப் பயன்படுத்த வேண்டும் ?

 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மீதமுள்ள நேரத்தில், குறியீடு வாசனை வீசுகிறது. இது ஒரு கேள்விக்குரிய வடிவமைப்பு முடிவு.

மாற்றத்தை கடினமாக்கும் வாசனை

இந்த வாசனைகள் மிகவும் தீவிரமானவை. மற்ற வாசனைகள் முக்கியமாக குறியீட்டைப் புரிந்துகொள்வதை கடினமாக்குகின்றன, ஆனால் இவை உங்களை மாற்றுவதைத் தடுக்கின்றன. நீங்கள் ஏதேனும் புதிய அம்சங்களை அறிமுகப்படுத்த முயற்சிக்கும்போது, ​​டெவலப்பர்களில் பாதி பேர் வெளியேறுகிறார்கள், பாதி பேர் பைத்தியமாகிவிடுவார்கள்.

இணையான பரம்பரை படிநிலைகள்

ஒரு வகுப்பை துணைப்பிரிவு செய்ய நீங்கள் வேறு வகுப்பிற்கு மற்றொரு துணைப்பிரிவை உருவாக்க வேண்டியிருக்கும் போது இந்த சிக்கல் வெளிப்படுகிறது.

சீராக விநியோகிக்கப்பட்ட சார்புகள்

எந்த மாற்றங்களுக்கும் நீங்கள் ஒரு வகுப்பின் அனைத்து பயன்பாடுகளையும் (சார்புநிலைகள்) பார்க்க வேண்டும் மற்றும் நிறைய சிறிய மாற்றங்களைச் செய்ய வேண்டும். ஒரு மாற்றம் - பல வகுப்புகளில் திருத்தங்கள்.

மாற்றங்களின் சிக்கலான மரம்

இந்த வாசனை முந்தையதற்கு எதிரானது: மாற்றங்கள் ஒரு வகுப்பில் அதிக எண்ணிக்கையிலான முறைகளை பாதிக்கின்றன. ஒரு விதியாக, அத்தகைய குறியீடானது அடுக்கடுக்கான சார்புகளைக் கொண்டுள்ளது: ஒரு முறையை மாற்றுவதன் மூலம் நீங்கள் மற்றொரு ஒன்றை சரிசெய்ய வேண்டும், பின்னர் மூன்றாவது மற்றும் பல. ஒரு வகுப்பு - பல மாற்றங்கள்.

"குப்பை நாற்றம்"

தலைவலியை ஏற்படுத்தும் நாற்றங்களின் மாறாக விரும்பத்தகாத வகை. பயனற்ற, தேவையற்ற, பழைய குறியீடு. அதிர்ஷ்டவசமாக, நவீன ஐடிஇ மற்றும் லிண்டர்கள் அத்தகைய நாற்றங்களை எச்சரிக்க கற்றுக்கொண்டன.

ஒரு முறையில் அதிக எண்ணிக்கையிலான கருத்துகள்

ஒரு முறை கிட்டத்தட்ட ஒவ்வொரு வரியிலும் நிறைய விளக்கக் கருத்துக்களைக் கொண்டுள்ளது. இது பொதுவாக ஒரு சிக்கலான அல்காரிதம் காரணமாகும், எனவே குறியீட்டை பல சிறிய முறைகளாகப் பிரித்து விளக்கமளிக்கும் பெயர்களைக் கொடுப்பது நல்லது.

நகல் குறியீடு

வெவ்வேறு வகுப்புகள் அல்லது முறைகள் ஒரே குறியீடு தொகுதிகளைப் பயன்படுத்துகின்றன.

சோம்பேறி வகுப்பு

ஒரு வகுப்பு பெரியதாக திட்டமிடப்பட்டிருந்தாலும், மிகக் குறைந்த செயல்பாடுகளை எடுத்துக்கொள்கிறது.

பயன்படுத்தப்படாத குறியீடு

ஒரு வர்க்கம், முறை அல்லது மாறி குறியீட்டில் பயன்படுத்தப்படவில்லை மற்றும் இறந்த எடை.

அதிகப்படியான இணைப்பு

இந்த வகை நாற்றங்கள் குறியீட்டில் அதிக எண்ணிக்கையிலான நியாயப்படுத்தப்படாத உறவுகளால் வகைப்படுத்தப்படுகின்றன.

வெளிப்புற முறைகள்

ஒரு முறை அதன் சொந்த தரவை விட மற்றொரு பொருளின் தரவைப் பயன்படுத்துகிறது.

பொருத்தமற்ற நெருக்கம்

ஒரு வகுப்பு மற்றொரு வகுப்பின் செயல்படுத்தல் விவரங்களைப் பொறுத்தது.

நீண்ட வகுப்பு அழைப்புகள்

ஒரு வகுப்பு மற்றொன்றை அழைக்கிறது, இது மூன்றில் இருந்து தரவைக் கோருகிறது, நான்காவிடமிருந்து தரவைப் பெறுகிறது மற்றும் பல. இத்தகைய நீண்ட தொடர் அழைப்புகள் தற்போதைய வகுப்பு கட்டமைப்பில் அதிக சார்பு என்று பொருள்.

பணி-வியாபாரி வகுப்பு

ஒரு பணியை மற்றொரு வகுப்பிற்கு அனுப்புவதற்கு மட்டுமே ஒரு வகுப்பு தேவை. ஒருவேளை அது அகற்றப்பட வேண்டுமா?

மறுசீரமைப்பு நுட்பங்கள்

விவரிக்கப்பட்ட குறியீடு வாசனையை அகற்ற உதவும் அடிப்படை மறுசீரமைப்பு நுட்பங்களைப் பற்றி கீழே விவாதிப்போம்.

ஒரு வகுப்பைப் பிரித்தெடுக்கவும்

ஒரு வகுப்பு பல செயல்பாடுகளை செய்கிறது. அவர்களில் சிலர் வேறு வகுப்பிற்கு மாற்றப்பட வேண்டும். எடுத்துக்காட்டாக, எங்களிடம் ஒரு 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. ஸ்டீவ் மெக்கானலின் "கோட் கம்ப்ளீட்", இது அழகான மற்றும் நேர்த்தியான குறியீட்டிற்கான கொள்கைகளை அமைக்கிறது.