புதிய புரோகிராமர்கள் செய்த பிரபலமான தவறுகள்

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