అనుభవం లేని ప్రోగ్రామర్లు చేసిన పాపులర్ తప్పులు

1. వస్తువులతో పోల్చడం==

కొత్త ప్రోగ్రామర్‌ల యొక్క ఇష్టమైన తప్పు ఏమిటంటే, ==ఆపరేటర్‌ని ఉపయోగించి వస్తువులను (ముఖ్యంగా స్ట్రింగ్‌లు) పోల్చడం. ఉదాహరణకి:

Scanner console = new Scanner(System.in);
String s1 = console.nextLine();
String s2 = console.nextLine();
if (s1 == s2)
{
   System.out.println("The strings are equal");
}

ఈ కోడ్ "ది స్ట్రింగ్స్ ఈక్వల్" అని ఎప్పటికీ ప్రదర్శించదు, ఎందుకంటే ifస్టేట్‌మెంట్ రెండు వేర్వేరు స్ట్రింగ్ ఆబ్జెక్ట్‌లకు సూచనలను పోలుస్తుంది.

కోడ్ యొక్క సరైన సంస్కరణ ఇక్కడ ఉంది:

Scanner console = new Scanner(System.in);
String s1 = console.nextLine();
String s2 = console.nextLine();
if (s1.equals(s2))
{
   System.out.println("The strings are equal");
}

2. Stringవస్తువును మార్చడం

కొత్త ప్రోగ్రామర్లు తరగతిలోని అన్ని వస్తువులు మార్పులేనివని మరియు తరగతిలోని ప్రతి పద్ధతి Stringకొత్త వస్తువును తిరిగి ఇస్తుందని తరచుగా మరచిపోతారు - ప్రస్తుత వస్తువు ఎప్పటికీ మారదు.

ఉదాహరణ:

String s = "Hello";
s.toUpperCase (); // Convert to uppercase

ఈ కోడ్ సరైన కోడ్‌కి చాలా పోలి ఉంటుంది, కానీ ఇది ఊహించిన విధంగా పని చేయదు. పద్ధతి toUpperCase()దానిని పిలిచే వస్తువును మార్చదు. సరైన కోడ్ ఇలా ఉంటుంది:

String s = "Hello";
String result = s.toUpperCase(); // Convert to uppercase

3. శ్రేణి యొక్క మూలకాల వస్తువులను ప్రారంభించడం మర్చిపోవడం

శ్రేణి వేరియబుల్‌ని ప్రారంభించడం మర్చిపోవడం మరొక సాధారణ తప్పు. ఉదాహరణ:

int[] array;
array[0] = 1;
array[0] = 2;

ఈ కోడ్ పని చేయదు: మీరు శ్రేణి యొక్క మూలకాలను నిల్వ చేసే కంటైనర్ ఆబ్జెక్ట్‌కు సూచనకు సమానమైన శ్రేణి వేరియబుల్‌ను స్పష్టంగా సెట్ చేయాలి.

int[] array = new int[10];
array[0] = 1;
array[0] = 2;

4. ఇన్‌స్టాన్స్ వేరియబుల్‌కు బదులుగా లోకల్ వేరియబుల్‌ని ఉపయోగించడం.

కొత్తవారు వేరియబుల్స్ కోసం పొడవైన మరియు అర్థవంతమైన పేర్లతో రావడానికి ఇష్టపడరు. వారు తరచుగా ఒకే-అక్షరాల పేర్లను ఉపయోగిస్తారు: a, b, i, మొదలైనవి. కోడ్‌లో అనేక వేరియబుల్స్ ఉన్నప్పుడు చేయడం చాలా క్రూరమైన పని:

class Solution
{
  public static int a = 99;
  public static int i = 100;

  public static void main(String[] args)
  {
    int[] a = new int[i];
    for (int i = 0; i < 10; i++)
    {
      a[i] = a;
    }
  }
}

ఎగువ కోడ్ కంపైల్ చేయబడదు. సరైన సంస్కరణ ఇలా కనిపిస్తుంది:

class Solution
{
   public static int value = 99;
   public static int count = 100;

   public static void main(String[] args)
   {
      int[] a = new int[count];
      for (int i = 0; i < count; i++)
      {
         a[i] = value;
      }
   }
}

5. సేకరణ అంశాన్ని తీసివేయడం

చాలా తరచుగా ఒక నిర్దిష్ట మూలకం సేకరణ నుండి తీసివేయవలసిన పరిస్థితులు ఉన్నాయి. కోడ్ దాదాపు ఇలా కనిపిస్తుంది:

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);

for (Integer value: list)
   if (value < 0)
      list.remove(value);

ఈ కోడ్ పని చేయదు, ఎందుకంటే మీరు సేకరణ యొక్క మూలకాలను ఏకకాలంలో ప్రయాణించడానికి మరియు ఆ సేకరణను సవరించడానికి ప్రతి లూప్‌ను ఉపయోగించలేరు.

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

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);

ArrayList<Integer> copy = new ArrayList<Integer>(list);
for (Integer value: copy)
   if (value < 0)
      list.remove(value);

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

ఉదాహరణ:

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);

list.removeIf( x-> x<0 );

6. మాడిఫైయర్‌తో అనేక తరగతులను publicఒకే ఫైల్‌లో ఉంచడం

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

public class Solution
{
}
public class Main
{
}

public class Solution
{
}
class Main
{
}

public class Solution
{
  public static class Main
  {
  }
}

main()7. స్టాటిక్ పద్ధతి నుండి తరగతి యొక్క సాధారణ (నాన్-స్టాటిక్) పద్ధతులను పిలవడం

main()కొన్నిసార్లు కొత్త ప్రోగ్రామర్లు నాన్-స్టాటిక్ వేరియబుల్స్ మరియు మెథడ్‌లను మెథడ్ లేదా ఇతర స్టాటిక్ మెథడ్స్ నుండి యాక్సెస్ చేయడానికి ప్రయత్నిస్తారు . అలాంటి కోడ్ పని చేయదు, వాస్తవానికి.

public class Solution
{
   public int n = 100;
   public int[] createArray()
   {
      return new int[n];
   }

   public static void main(String[]args)
   {
      int[] array = createArray();
   }
}

ప్రధాన పద్ధతి స్టాటిక్ పద్ధతులు/చరరాశులను మాత్రమే సూచించగలదు. బాగా, లేదా అది మొదట తరగతి యొక్క ఉదాహరణను సృష్టించాలి Solution, ఆపై మాత్రమే ఆ వస్తువు యొక్క నాన్-స్టాటిక్ పద్ధతులను కాల్ చేయండి. ఉదాహరణ:

public class Solution
{
  public static int n = 100;

  public static int[] createArray()
  {
    return new int[n];
  }

  public static void main(String[]args)
  {
    int[] array = createArray();
  }
}

public class Solution
{
  public int n = 100;

  public int[] createArray()
  {
    return new int[n];
  }

  public static void main(String[]args)
  {
    Solution sol = new Solution();
    int[] array = sol.createArray();
  }
}

8. ఒక పద్ధతి వలె కన్స్ట్రక్టర్‌ను ప్రకటించడం

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

public class Person
{
   private String value;

   void Person(String value)
   {
      this.value = value;
   }
}

public class Person
{
   private String value;

   constructor(String value)
   {
      this.value = value;
   }
}

public class Person
{
   private String value;

   Person(String value)
   {
      value = value;
   }
}

public class Person
{
   private String value;

   Person(String value)
   {
      this.value = value;
   }
}

9. ఇంటర్‌ఫేస్‌ల యొక్క సరికాని వారసత్వం

జావా సృష్టికర్తలు దీన్ని ఆంగ్లానికి చాలా దగ్గరగా ఉండేలా చేయడానికి ప్రయత్నించారు, కాబట్టి వారు నిర్దిష్ట సంబంధిత కాన్సెప్ట్‌ల కోసం విభిన్న కీలకపదాలను ఎంచుకున్నారు.

తరగతి తరగతిని వారసత్వంగా పొందినప్పుడు, మీరు కీవర్డ్‌ని ఉపయోగించాలి extends:

class Pet
{
}

class Cat extends Pet
{
}

తరగతి ఇంటర్‌ఫేస్‌ను వారసత్వంగా పొందినప్పుడు, మీరు కీవర్డ్‌ని ఉపయోగించాలి implements:

interface Meow
{
}

class Cat implements Meow
{
}

ఇంటర్‌ఫేస్ ఇంటర్‌ఫేస్‌ను వారసత్వంగా పొందినప్పుడు, extendsకీవర్డ్‌ని ఉపయోగించండి:

interface Meow
{
}

interface Voice extends Meow
{
}

break10. ఒక switchప్రకటనలో వదిలివేయడం

మరియు ఈ రోజు మనకు చివరి తప్పు, కానీ ప్రారంభకులకు చివరిది కాదు, breakఒక ప్రకటనలో ఒక ప్రకటనను చేర్చడంలో విఫలమైంది switch. ఉదాహరణ

LocalDate date = LocalDate.now();
DayOfWeek day = date.getDayOfWeek();
switch (day)
{
   case MONDAY:
      System.out.println("Monday");
   case TUESDAY:
      System.out.println("Tuesday");
   case WEDNESDAY:
      System.out.println("Wednesday");
   case THURSDAY:
      System.out.println("Thursday");
   case FRIDAY:
      System.out.println("Friday");
   case SATURDAY:
      System.out.println("Saturday");
   case SUNDAY:
      System.out.println("Sunday");
}

LocalDate date = LocalDate.now();
DayOfWeek day = date.getDayOfWeek();
switch (day)
{
   case MONDAY:
      System.out.println("Monday");
      break;
   case TUESDAY:
      System.out.println("Tuesday");
      break;
   case WEDNESDAY:
      System.out.println("Wednesday");
      break;
   case THURSDAY:
      System.out.println("Thursday");
      break;
   case FRIDAY:
      System.out.println("Friday");
      break;
   case SATURDAY:
      System.out.println("Saturday");
      break;
   case SUNDAY:
      System.out.println("Sunday");
      break;
}