జనాదరణ పొందిన సంకలన లోపాలు

1. సెమికోలన్‌ను మర్చిపోవడం

జావా ప్రోగ్రామర్లు చేసే అత్యంత సాధారణ పొరపాటు సెమికోలన్‌ను కలిగి ఉంటుంది. లేదా, అది ఎక్కడ ఉండాలో అది లేకపోవడం.

పద్ధతిలోని ప్రతి ప్రకటన తప్పనిసరిగా సెమికోలన్‌తో ముగియాలి. సెమికోలన్ అనేది స్టేట్‌మెంట్‌లు లేదా కమాండ్‌లను వేరు చేస్తుంది: ఈ విధంగా మనం జావా కంపైలర్‌కి ఒక కమాండ్ ముగుస్తుంది మరియు తదుపరిది ప్రారంభమవుతుంది.

లోపాల ఉదాహరణలు:

int a
int b = 5
int c = a + b

int a;
int b = 5;
int c = a + b;

System.out.println("Hello")

System.out.println("Hello");

if (2 > 3)
   System.out.println("Are we in Australia?")

if (2 > 3)
   System.out.println("Are we in Australia?");

2. కోట్‌లను మూసివేయడం మర్చిపోవడం

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

కోడ్‌లోని ప్రతి స్ట్రింగ్ తప్పనిసరిగా డబుల్ కొటేషన్ మార్కులతో (") రెండు వైపులా జతచేయబడాలి. బిగినర్స్ ప్రోగ్రామర్లు చాలా తరచుగా టెక్స్ట్ ప్రారంభంలో కొటేషన్ మార్కులను ఉంచుతారు, కానీ వారు వాటిని చివరిలో మూసివేయడం మర్చిపోతారు.

ఇవి కొన్ని ఉదాహరణలు:

String s = "Hello;

String s = "Hello";

System.out.println("Hello);

System.out.println("Hello");

String s = "Hello";
String message = s + " and by. ;

String s = "Hello";
String message = s + " and bye.";

3. తీగలను అతికించేటప్పుడు ప్లస్ గుర్తును చేర్చడం మర్చిపోవడం

స్ట్రింగ్స్‌తో పనిచేసేటప్పుడు మరొక సాధారణ తప్పు ఏమిటంటే, తీగలను అతుక్కొని ఉన్నప్పుడు ప్లస్ గుర్తును వ్రాయడం మర్చిపోవడం. టెక్స్ట్ మరియు వేరియబుల్స్ కోడ్‌లో సుదీర్ఘ వ్యక్తీకరణలో సంయోగం చేయబడినప్పుడు ఈ లోపం ముఖ్యంగా ప్రబలంగా ఉంటుంది.

ఇవి కొన్ని ఉదాహరణలు:

String s = "Hello";
String message = s  " and bye.";

String s = "Hello";
String message = s + " and bye.";

int age = 35;
System.out.println("Age=" age);

int age = 35;
System.out.println("Age=" + age);

int age = 35;
System.out.println("Age=", age);

int age = 35;
System.out.println("Age=" + age);

4. కర్లీ జంట కలుపులను మూసివేయడం మర్చిపోవడం

ఇది చాలా సాధారణ తప్పు. ఇది విలక్షణమైన రెండు పరిస్థితులు ఉన్నాయి:

మొదటి పరిస్థితి: మీరు ఎక్కడి నుండైనా కోడ్‌ని కాపీ చేయాలని నిర్ణయించుకున్నారు మరియు అనుకోకుండా కొన్ని కర్లీ బ్రేస్‌లను కోల్పోయారు. రెండవ పరిస్థితి: ప్రతి ఓపెన్ కుండలీకరణం ముగింపు కుండలీకరణంతో సరిపోలుతుందని నిర్ధారించుకోవడానికి మీరు మిమ్మల్ని ఇబ్బంది పెట్టడం లేదు.

ఈ లోపాలను నివారించడానికి, సాధారణంగా ప్రారంభ ప్రోగ్రామర్లు ముగింపు కర్లీ బ్రేస్‌ను ఓపెనింగ్ కింద వ్రాయమని సిఫార్సు చేస్తారు.

ఉదాహరణలు:

if (2 < 3)
{
   if (3 < 4)
   {
      System.out.println("Mathematics!");
   }

if (2 < 3)
{
   if (3 < 4)
   {
      System.out.println("Mathematics!");
   }
}

{
   if (2 < 3)
   {
      if (3 < 4)
      {
         System.out.println("Mathematics!");
      }
   }

{
   if (2 < 3)
   {
      if (3 < 4)
      {
         System.out.println("Mathematics!");
      }
   }
}

5. కుండలీకరణాలను జోడించడం మర్చిపోవడం

ఇలాంటి పరిస్థితుల్లో కుండలీకరణాలు అవసరం లేని ప్రోగ్రామింగ్ భాషలను తెలిసిన డెవలపర్‌లు చాలా తరచుగా ఈ పొరపాటు చేస్తారు.

ఒక అవకాశం ఏమిటంటే, వారు ఒక పద్ధతి కాల్ చివరిలో కుండలీకరణాలను ఉంచడం మర్చిపోతారు:

if-elseమరొక అవకాశం ఏమిటంటే, వారు ఒక ప్రకటన యొక్క స్థితిని కుండలీకరణాల్లో మూసివేయడం మర్చిపోతారు .

ఉదాహరణలు:

System.out.println("Hello!");
System.out.println;
System.out.println("And bye!");

System.out.println("Hello!");
System.out.println();
System.out.println("And bye!");

if 2 < 3
{
   if 3 < 4
   {
      System.out.println("Mathematics!");
   }
}

if (2 < 3)
{
   if (3 < 4)
   {
      System.out.println("Mathematics!");
   }
}

main6. పద్ధతి డిక్లరేషన్‌ను తప్పుగా రాయడం

వారు రక్తపాత పద్ధతిని ప్రకటించిన వెంటనే main! ఈ పేలవమైన పద్ధతి వలె కొత్తవారిని ఆకర్షించే ఏదీ బహుశా లేదు. ముఖ్యంగా, అప్పుడు వారు ఎల్లప్పుడూ ఆశ్చర్యపోతారు మరియు వారి ప్రోగ్రామ్ ఎందుకు ప్రారంభించబడదు అని ఆశ్చర్యపోతారు?

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

ఉదాహరణలు:

static void main(String[] args)

public void main(String[] args)

public main(String[] args)

void main(String[] args)

public static void main(String args)

public static void main()

public static int main(String[] args)

7. ఫైల్ పేరు తరగతి పేరు నుండి భిన్నంగా ఉంటుంది

జావా ప్రమాణం ప్రకారం, అన్ని జావా తరగతులు తప్పనిసరిగా తరగతి పేరు వలె అదే పేరుతో ఫైల్‌లో నిల్వ చేయబడాలి. మరియు ముందుగా చెప్పినట్లుగా, లేఖల కేసు ఇక్కడ ముఖ్యమైనది:

Solution.java

Solution

Solutions.java

Solution

solution.java

Solution

Solution.txt

Solution

Solution.java

solution

వాస్తవానికి, .java పొడిగింపుతో ఫైల్‌లో అనేక తరగతులను ప్రకటించవచ్చు, కానీ వాటిలో ఒకటి మాత్రమే publicతరగతి పేరుకు ముందు పదాన్ని కలిగి ఉంటుంది. మరియు ఈ పేరు తప్పనిసరిగా ఫైల్ పేరుకు సరిపోలాలి.

.java ఫైల్ ఎల్లప్పుడూ తప్పనిసరిగా ఫైల్ పేరు వలె ఉండే తరగతిని కలిగి ఉండాలి మరియు ఆ తరగతికి మాడిఫైయర్ ఉండాలి public. ఉదాహరణ:

public class Solution
{
}

class Apple
{
}

class Pineapple
{
}

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

public class Solution
{
   public class Apple
   {
   }

   public static class Pineapple
   {
   }
}

8. రాయడం మర్చిపోవడంpackage

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

అందుకే ప్రతి తరగతి ప్యాకేజీకి సంబంధించిన సూచనతో ప్రారంభం కావాలి. ఉదాహరణ

public class Solution
{
}

package com.codegym.tasks.task0001;

public class Solution
{
}

9. జోడించడం మర్చిపోవడంimport

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

ఉదాహరణ:

public class Solution
{
   java.util.Scanner scanner = new java.util.Scanner();
}

import java.util.Scanner;

public class Solution
{
   Scanner console = new Scanner();
}

Scannerరెండు ఎంపికలు పని చేస్తాయి, కానీ మీరు జోడించకుండా మీ కోడ్‌లో వ్రాస్తే import, కంపైలర్ ఏ ప్యాకేజీ నుండి క్లాస్ తీసుకోవాలో అర్థం చేసుకోలేరు Scannerమరియు మీ ప్రోగ్రామ్ కంపైల్ చేయదు.