பிரபலமான தொகுத்தல் பிழைகள்

"ஏய், இளம் ஆட்சேர்ப்பு, எளிய திட்டங்களில் கூட, ஒவ்வொரு நாளும் பல தவறுகளைச் செய்பவர்!

"உம்... ஹாய், டியாகோ. பையன், மக்களை எப்படி உற்சாகப்படுத்துவது என்பது உங்களுக்கு உண்மையிலேயே தெரியும்!"

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

"ஓஹோ, அப்படியானால் நன்றி, என் மிகவும் உலோக ஆசிரியர்! .

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

அரைப்புள்ளியை மறத்தல்

"ஜாவா புரோகிராமர்கள் செய்யும் பொதுவான தவறு அரைப்புள்ளியை உள்ளடக்கியது. அல்லது அது இருக்க வேண்டிய இடத்தில் இல்லாதது."

"உண்மை என்னவென்றால்... நான் இந்த குற்றத்தை மீண்டும் மீண்டும் செய்திருக்கிறேன்."

"ஒரு முறையின் உள்ளே இருக்கும் ஒவ்வொரு கூற்றும் அரைப்புள்ளியுடன் முடிவடைய வேண்டும். அரைப்புள்ளி என்பது அறிக்கைகள் அல்லது கட்டளைகளைப் பிரிக்கிறது: ஜாவா கம்பைலருக்கு ஒரு கட்டளை முடிந்து அடுத்தது தொடங்கும் இடத்தில் இப்படித்தான் சொல்கிறோம்.

பிழைகளின் எடுத்துக்காட்டுகள்:

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

மேற்கோள்களை மூட மறந்துவிட்டது

"ஜாவாவில் புதிதாக வருபவர்களின் இரண்டாவது பொதுவான தவறு, குறியீட்டில் ஒரு சரத்தை எழுதி, மேற்கோளை மூட மறந்துவிடுவது.

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

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.";

சரங்களை ஒன்றாக ஒட்டும்போது கூட்டல் குறியைச் சேர்க்க மறந்துவிடுகிறது

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

இங்கே சில உதாரணங்கள்:

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

சுருள் பிரேஸ்களை மூட மறந்துவிடுதல்

"இது மிகவும் பொதுவான தவறு. இது பொதுவான இரண்டு சூழ்நிலைகள் உள்ளன:

1. எங்கிருந்தோ குறியீட்டை நகலெடுக்க முடிவு செய்தீர்கள், தற்செயலாக சில சுருள் பிரேஸ்களைத் தவறவிட்டீர்கள்.
2. ஒவ்வொரு திறந்த அடைப்புக்குறியும் ஒரு மூடும் அடைப்புக்குறியுடன் பொருந்துகிறதா என்பதை உறுதிப்படுத்த நீங்கள் உங்களைத் தொந்தரவு செய்யவில்லை."

"இரண்டாவது விருப்பம் நான் என்ன செய்வது. சில சமயங்களில் நான் மறந்து விடுகிறேன்!" .

"இந்தப் பிழைகளைத் தவிர்ப்பதற்காக, தொடக்கப் புரோகிராமர்கள், க்ளோசிங் கர்லி பிரேஸை திறப்பின் அடியில் எழுதுவது வழக்கமாக பரிந்துரைக்கப்படுகிறது.

எடுத்துக்காட்டுகள்:

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

அடைப்புக்குறிகளைச் சேர்க்க மறந்துவிடுகிறது

"பெரும்பாலும், இதே போன்ற சூழ்நிலைகளில் அடைப்புக்குறிகள் தேவைப்படாத நிரலாக்க மொழிகளை அறிந்த டெவலப்பர்களால் இந்த தவறு செய்யப்படுகிறது.

ஒரு சாத்தியம் என்னவென்றால், ஒரு முறை அழைப்பின் முடிவில் அடைப்புக்குறிகளை வைக்க அவர்கள் மறந்து விடுகிறார்கள்:

மற்றொரு சாத்தியம் என்னவென்றால், ஒரு அறிக்கையின் நிபந்தனையை 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!");
   }
}

mainமுறை அறிவிப்பை தவறாக எழுதுதல்

"அவர்கள் இரத்தக்களரி முறையை அறிவித்தவுடன் 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)

கோப்பின் பெயர் வகுப்பின் பெயரிலிருந்து வேறுபட்டது

"ஜாவா தரநிலையின்படி, அனைத்து ஜாவா வகுப்புகளும் வகுப்பின் பெயரின் அதே பெயரில் ஒரு கோப்பில் சேமிக்கப்பட வேண்டும். மேலும் முன்னர் குறிப்பிட்டபடி, எழுத்துக்களின் வழக்கு இங்கே முக்கியமானது:

public"உண்மையில், .java நீட்டிப்புடன் ஒரு கோப்பில் பல வகுப்புகள் அறிவிக்கப்படலாம், ஆனால் அவற்றில் ஒன்று மட்டுமே வகுப்பின் பெயருக்கு முன் வார்த்தையை வைத்திருக்க முடியும் . மேலும் இது கோப்பு பெயருடன் பொருந்த வேண்டும்.

"ஒரு .java கோப்பு எப்பொழுதும் ஒரு வகுப்பைக் கொண்டிருக்க வேண்டும், அதன் பெயர் கோப்புப் பெயரைப் போலவே இருக்கும், மேலும் அந்த வகுப்பிற்கு மாற்றியமைப்பாளர் இருக்க வேண்டும் public. எடுத்துக்காட்டு:

public class Solution
{
}

class Apple
{
}

class Pineapple
{
}

"கூடுதலாக, ஜாவா மொழியானது வகுப்புகளுக்குள் வகுப்புகளை எழுத உங்களை அனுமதிக்கிறது. மேலே உள்ள வரம்பைப் பெற இது மற்றொரு வழியாகும். ஒரு பொது வகுப்பு (மாற்றியமைப்புடன் கூடிய வகுப்பு public) ஒரு கோப்பில் அறிவிக்கப்பட்டு, கோப்பு பெயரின் அதே பெயரைக் கொண்டிருந்தால், இந்த பொது வகுப்பிற்குள் நீங்கள் விரும்பும் பல வகுப்புகளை நீங்கள் அறிவிக்கலாம். அதாவது, இவை இனி சாதாரண வகுப்புகளாக இருக்காது, மாறாக, அவை உள் அல்லது உள்ளமைக்கப்பட்ட வகுப்புகளாக இருக்கும். எடுத்துக்காட்டு:

public class Solution
{
   public class Apple
   {
   }

   public static class Pineapple
   {
   }
}

எழுத மறந்துவிட்டதுpackage

"நிரல்கள் பொதுவாக ஆயிரக்கணக்கான வகுப்புகளைக் கொண்டிருப்பதால், அவை அனைத்திற்கும் எளிமையான, புரிந்துகொள்ளக்கூடிய மற்றும் தனித்துவமான பெயர்களைக் கண்டறிவது கடினமாக இருக்கும். அதனால்தான் ஜாவாவில் முக்கிய சொல்லைப் பயன்படுத்தி வகுப்புகளை தொகுப்புகளாகக் குழுவாக்குவது வழக்கம். கோப்புகள் தொகுக்கப்பட்ட விதம் package. கோப்புறைகளில்."

"ஆஹா, அதனால்தான் ஒவ்வொரு வகுப்பும் அது சார்ந்த பேக்கேஜின் குறிப்புடன் தொடங்க வேண்டும்."

"சரியாக. இங்கே ஒரு உதாரணம்:

public class Solution
{
}

package en.codegym.tasks.task0001;

public class Solution
{
}

சேர்க்க மறந்துவிட்டது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, மேலும் உங்கள் நிரல் தொகுக்கப்படாது."

"நன்றி, டியாகோ. இந்தப் பாடம் என்னை அதிக கவனம் செலுத்த வைக்கும்."

"அதைத்தான் எண்ணிக் கொண்டிருந்தேன். நல்ல அதிர்ஷ்டம்!"