IDEA லைஃப் ஹேக்ஸ்

1. தன்னிரக்கம் (தாவல்)

IntelliJ IDEA மிகவும் புத்திசாலித்தனமான வளர்ச்சி சூழல். சிலர் இது ஜாவா மேம்பாட்டிற்கான சிறந்த IDE மட்டுமல்ல, உலகின் மிகச் சிறந்த IDE என்று நம்புகிறார்கள் . இது உண்மையிலிருந்து வெகு தொலைவில் இல்லை என்பதை ஒப்புக்கொள்கிறேன்.

எடுத்துக்காட்டாக, IntelliJ IDEA தன்னியக்க நிறைவு எனப்படும் இந்த அற்புதமான விஷயத்தைக் கொண்டுள்ளது. IntelliJ IDEA உங்கள் திட்டத்தில் உள்ள அனைத்து கோப்புகளையும் அலசுகிறது மற்றும் பகுப்பாய்வு செய்கிறது (நீங்கள் பயன்படுத்தும் அனைத்து நூலகங்கள் உட்பட). உங்களிடம் என்ன வகுப்புகள் உள்ளன மற்றும் அந்த வகுப்புகள் என்ன முறைகள் மற்றும் மாறிகள் உள்ளன என்பதை இது புரிந்துகொள்கிறது. உங்கள் குறியீட்டை எழுத உங்களுக்கு உதவ, அது அந்தத் தகவலைப் பயன்படுத்துகிறது.

நீங்கள் ஒரு வார்த்தையை தட்டச்சு செய்யத் தொடங்குங்கள், அது உடனடியாக அதை முடிப்பதற்கான குறிப்புகளை வழங்குகிறது. பொதுவாகப் பயன்படுத்தப்படும் தன்னியக்க விசைகளில் ஒன்று Tab .

உதாரணமாக, நீங்கள் "சிஸ்டம்" என்று எழுத விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். இதைச் செய்ய, நீங்கள் "Sys" எனத் தட்டச்சு செய்து "Tab" விசையை அழுத்தவும்: IDEA உங்களுக்கான மீதமுள்ளவற்றை முடிக்கும்.

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

அல்லது நீங்கள் InputStreamReader என்ற வகுப்பின் பெயரை எழுத விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம் . IntelliJ IDEA உங்கள் நேரத்தைச் சேமிக்கும்: நீங்கள் மூன்று பெரிய எழுத்துக்களை " ISR " ( I nput S tream R eader ) தட்டச்சு செய்து Tab ஐ அழுத்தவும் . IDEA நீங்கள் எழுதியதை InputStreamReader ஆக மாற்றும். இது கிட்டத்தட்ட மந்திரம்.

4.2 நேரடி டெம்ப்ளேட்கள்: psvm, sout, psfs, fori

தொழில்முறை புரோகிராமர்கள் IntelliJ IDEA ஐ விரும்புவதற்கு ஆயிரக்கணக்கான காரணங்கள் உள்ளன, ஆனால் இது ஆரம்பநிலைக்கு ஏதாவது உள்ளது. உதாரணத்திற்கு:

முக்கிய முறை

public static void main(String[] args) ஒரு நொடிக்கும் குறைவான நேரத்தில் எழுத வேண்டும் என்று வைத்துக்கொள்வோம் .

இதைச் செய்ய, psvm என்ற 4 எழுத்துக்களைத் தட்டச்சு செய்து Tab ஐ அழுத்தவும் . IDEA ஆனது " psvm " ஐ " பொது நிலையான வெற்றிட பிரதான (ஸ்ட்ரிங்[] args) " உடன் மாற்றும் . மந்திரம்.

பிஎஸ்விஎம் வரிசையை நினைவில் கொள்வது மிகவும் எளிதானது   - இது "பொது நிலையான வெற்றிட முக்கிய" என்பதன் சுருக்கமாகும்.

கன்சோல் வெளியீடு

System.out.println() விரைவாக எழுத ஒரு வழியும் உள்ளது ;

இதைச் செய்ய, நீங்கள் 4 எழுத்துக்களை (" சவுட் ") எழுதி Tab ஐ அழுத்தவும் . IDEA "Sout" ஐ " System.out.println(); " உடன் மாற்றும்

இதை நினைவில் கொள்வதும் எளிதானது: சௌட்டில் உள்ள 4 எழுத்துக்கள் S அமைப்பிலிருந்து வந்தவை . வெளியே .println

ஒரு சரம் மாறிலியை அறிவிக்கிறது

ஒரு சரம் மாறியை விரைவாக அறிவிக்க ஒரு வழி உள்ளது (வகுப்பு மட்டத்தில்).

இதைச் செய்ய, நீங்கள் மீண்டும் 4 எழுத்துக்களை எழுத வேண்டும் (" psfs ") மற்றும் Tab ஐ அழுத்தவும் . IDEA ஆனது "psfs" ஐ " பொது நிலையான இறுதி சரம் " உடன் மாற்றும் .

இதை நினைவில் கொள்வதில் உங்களுக்கு சிரமம் இருக்காது: p ublic s tatic final S ட்ரிங்கிலிருந்து வரும் 4 எழுத்துக்களால் psfs ஆனது .

எந்தவொரு தரவு வகையிலும் இதேபோன்ற சுருக்கம் உள்ளது: "psf", இது பொது நிலையான இறுதியைக் குறிக்கிறது

சுழல்கள்

fori + Tab கலவையைப் பயன்படுத்தி IDEA இல் ஒரு சுழற்சியை விரைவாக எழுதலாம் . நீங்கள் இதைச் செய்யும்போது, ​​IDEA ஆனது பின்வரும் குறியீட்டைக் கொண்டு fori ஐ மாற்றும் :

for (int i = 0; i < ; i++) {
}

i கவுண்டர் மாறிக்கான அதிகபட்ச மதிப்பில் நீங்கள் எழுத வேண்டும்.

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

3. சுற்றியுள்ள குறியீடு துண்டுகள்: Ctrl+Alt+T

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

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

ஆனால் ஒரு சுலபமான வழி உள்ளது: ஏற்கனவே உள்ள குறியீட்டை ஒரு லூப்பில் சுற்றிக்கொள்ளலாம், மற்றதை IntelliJ IDEA தானாகவே செய்யும். நீங்கள் 3 விஷயங்களைச் செய்ய வேண்டும்:

1. மற்ற குறியீட்டுடன் நீங்கள் சுற்றிக்கொள்ள விரும்பும் குறியீட்டை முன்னிலைப்படுத்தவும்
2. Ctrl+Alt+Tஐ அழுத்தவும்
3. சுற்றியுள்ள அறிக்கைகளைச் சேர்ப்பதற்கான விருப்பங்களில் ஒன்றைத் தேர்ந்தெடுக்கவும்:
   1. என்றால்
   2. என்றால்-வேறு
   3. போது
   4. போது செய்ய
   5. க்கான
   6. பிடிக்க முயற்சிக்கவும்
   7. இறுதியாக முயற்சிக்கவும்
   8. இறுதியாக பிடிக்க முயற்சிக்கவும்
   9. ஒத்திசைக்கப்பட்டது

ஐடியாவில் உள்ள மெனுவின் உதாரணம் இங்கே:

4. குறியீடு நடை: Ctrl+Alt+L

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

உங்கள் குறியீட்டை அழகாக வைத்திருக்க, நீங்கள் 3 பொத்தான்களை அழுத்த வேண்டும்: Ctrl+Alt+L

நீங்கள் இந்த கலவையை அழுத்தியவுடன், IntelliJ IDEA ஆனது தற்போதைய கோப்பில் உள்ள அனைத்து குறியீட்டையும் உடனடியாக வடிவமைக்கும், தேவையான இடங்களில் இடைவெளிகள் மற்றும் தாவல்களை வைக்கும். இது இனி குறியீடாக இருக்காது, ஆனால் கண் மிட்டாய்.

உதாரணமாக:

public class Main {
   public static void main(String[] args) {
System.out.println("Hello World!");
System.out.println();
   if (2 < 3)   {
System.out.println("Opps");   }

for (int i = 0; i < 10; i++) {
System.out.println(i);
      }
   }
}

public class Main
{
   public static void main(String[] args)
   {
      System.out.println("Hello World!");
      System.out.println();
      if (2 < 3)
      {
         System.out.println("Opps");
      }

      for (int i = 0; i < 10; i++)
      {
         System.out.println(i);
      }
   }
}

மூலம், ஒவ்வொரு "குறியீடு பாணியும்" IntelliJ IDEA அமைப்புகளில் முழுமையாக தனிப்பயனாக்கக்கூடியது: