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

"హాయ్, అమిగో! తప్పుల గురించి మాట్లాడటం కొనసాగిద్దాం. ఈసారి, కంపైలర్ మీకు ఎల్లప్పుడూ సహాయం చేయని తప్పులను మేము విశ్లేషిస్తాము. శ్రద్ధ వహించండి మరియు మీరు మీ గురించి కొంత నేర్చుకుంటారు."

"నేను వినడానికి సిద్ధంగా ఉన్నాను, డియెగో. ఇది నాకు చాలా ఇబ్బందిగా ఉండదని నేను ఆశిస్తున్నాను."

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

"మా అగ్ర ఇష్టమైన కొత్త ప్రోగ్రామర్ తప్పుల జాబితా ఆపరేటర్‌ని ఉపయోగించి వస్తువులను (ముఖ్యంగా స్ట్రింగ్‌లు) పోల్చడంతో ప్రారంభమవుతుంది =="

ఉదాహరణ:

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");
}

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

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

" మార్పులేని అర్థం ఏమిటో నేను చాలా కాలం క్రితం నేర్చుకున్నాను , కానీ నేను దీన్ని చేశానని అనుకుంటున్నాను.

"నేను దాని గురించి చాలా ఖచ్చితంగా ఉన్నాను. ఉదాహరణ:

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

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

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

"సరిగ్గా. నేను అలా చేసాను, కానీ నాకు నిజంగా తప్పు ఏమిటో కూడా అర్థం కాలేదు. క్లారిఫికేషన్ కోసం ధన్యవాదాలు!"

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

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

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

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

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

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

"కొత్తవారు వేరియబుల్స్ కోసం పొడవైన మరియు అర్థవంతమైన పేర్లతో రావడానికి ఇష్టపడరు."

"ఇది చాలా నిజం. పనులు త్వరగా పూర్తి చేయడం కోసం, నేను కొన్నిసార్లు 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 < 10; i++)
      {
         a[i] = value;
      }
   }
}

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

"మీరు ఇప్పటికే కలెక్షన్లను పరిశీలించారా?"

"అక్షరాలా కేవలం ఒక కన్నుతో."

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

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);

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

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

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 );

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

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

public class Solution
{
}
public class Main
{
}

public class Solution
{
}
class Main
{
}

public class Solution
{
  public static class Main
  {
  }
}

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

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

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

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

" mainపద్ధతి స్టాటిక్ మెథడ్స్/వేరియబుల్స్‌ను మాత్రమే సూచించగలదు. సరే, లేదా అది మొదట క్లాస్ యొక్క ఉదాహరణను సృష్టించాలి 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();
  }
}

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

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

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;
   }
}

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

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

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

class Pet
{
}

class Cat extends Pet
{
}

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

interface Meow
{
}

class Cat implements Meow
{
}

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

interface Meow
{
}

interface Voice extends Meov
{
}

breakఒక 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;
}

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

"హా! ఇందులో సందేహం లేదు. నేను చదివాను, ట్రాక్ చేసాను, అలాగే కొనసాగించాను. కాబట్టి అప్రమత్తంగా ఉండండి!"

"???"

"మీరు చింతించకండి. నేను తమాషా చేస్తున్నాను. అప్రమత్తంగా ఉండండి మరియు తక్కువ తెలివితక్కువ తప్పులు చేయండి."