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

"வணக்கம், அமிகோ! தவறுகளைப் பற்றி தொடர்ந்து பேசுவோம். இந்த நேரத்தில், கம்பைலர் உங்களுக்கு எப்போதும் உதவாத தவறுகளை நாங்கள் ஆராய்வோம். கவனம் செலுத்துங்கள், உங்களைப் பற்றி நீங்கள் ஏதாவது கற்றுக் கொள்வீர்கள்."

"நான் கேட்க தயாராக இருக்கிறேன், டியாகோ. இது எனக்கு மிகவும் சங்கடமாக இருக்காது என்று நம்புகிறேன்."

பொருட்களை ஒப்பிடுதல்==

"எங்கள் முதல் விருப்பமான புதிய புரோகிராமர் தவறுகளின் பட்டியல், ஆபரேட்டரைப் பயன்படுத்தி பொருட்களை (குறிப்பாக சரங்களை) ஒப்பிடுவதன் மூலம் தொடங்குகிறது =="

உதாரணமாக:

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

"உங்களுக்குத் தெரியும், டியாகோ... நீங்கள் இங்கு வழங்கிய பிழைகளின் தொகுப்பைப் பார்க்கும்போது, ​​நீங்கள் எனது தனிப்பட்ட பத்திரிகையைப் படிப்பது போல் உணர்கிறீர்கள். அல்லது நான் பணிகளைத் தீர்ப்பதை நீங்கள் பார்த்துக் கொண்டிருக்கிறீர்கள்."

"ஹா! இதில் எந்த சந்தேகமும் இல்லை. நான் படித்து, கண்காணித்து, தொடர்ந்து செய்து வருகிறேன். அதனால் எச்சரிக்கையாக இரு!"

"???"

"நீங்கள் கவலைப்பட வேண்டாம். நான் வேடிக்கையாகச் சொல்கிறேன். விழிப்புடன் இருங்கள் மற்றும் முட்டாள்தனமான தவறுகளை குறைக்கவும்."