IDEA లైఫ్ హ్యాక్స్

1. స్వీయపూర్తి (ట్యాబ్)

IntelliJ IDEA అనేది చాలా తెలివైన అభివృద్ధి వాతావరణం. కొంతమంది ఇది జావా అభివృద్ధికి గొప్ప IDE మాత్రమే కాదు, ప్రపంచంలోని అత్యుత్తమ IDE అని నమ్ముతారు . ఏది, ఒప్పుకుంటే, సత్యానికి దూరంగా లేదు.

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

మీరు ఒక పదాన్ని టైప్ చేయడం ప్రారంభించండి మరియు అది వెంటనే పూర్తి చేయడానికి సూచనలను అందిస్తుంది. సాధారణంగా ఉపయోగించే ఆటోకంప్లీట్ కీలలో ఒకటి టాబ్ .

ఉదాహరణకు, మీరు "సిస్టమ్" అని వ్రాయాలనుకుంటున్నారని అనుకుందాం. దీన్ని చేయడానికి, మీరు "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 "ని " పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్(స్ట్రింగ్[] ఆర్గ్స్) " తో భర్తీ చేస్తుంది . మేజిక్.

సీక్వెన్స్ psvmని గుర్తుంచుకోవడం చాలా సులభం   — ఇది "పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్" యొక్క సంక్షిప్తీకరణ.

కన్సోల్ అవుట్‌పుట్

System.out.println()ని త్వరగా వ్రాయడానికి ఒక మార్గం కూడా ఉంది ;

దీన్ని చేయడానికి, మీరు 4 అక్షరాలు (" సౌట్ ") వ్రాసి ట్యాబ్ నొక్కండి . IDEA "సౌట్"ని " System.out.println(); " తో భర్తీ చేస్తుంది

ఇది గుర్తుంచుకోవడం కూడా సులభం: సౌట్‌లోని 4 అక్షరాలు S సిస్టమ్ నుండి వచ్చాయి . అవుట్ .println

స్ట్రింగ్ స్థిరాంకం ప్రకటించడం

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

దీన్ని చేయడానికి, మీరు మరోసారి 4 అక్షరాలు (" psfs ") వ్రాసి , Tab నొక్కండి . IDEA "psfs"ని " పబ్లిక్ స్టాటిక్ ఫైనల్ స్ట్రింగ్ " తో భర్తీ చేస్తుంది .

దీన్ని గుర్తుంచుకోవడంలో మీకు ఇబ్బంది ఉండదు: p ublic s tatic f inal 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. సమకాలీకరించబడింది

IDEAలోని మెనుకి ఉదాహరణ ఇక్కడ ఉంది:

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 సెట్టింగ్‌లలో పూర్తిగా అనుకూలీకరించబడుతుంది: