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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

6. 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)

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

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

Solution.java

Solution

Solutions.java

Solution

solution.java

Solution

Solution.txt

Solution

Solution.java

solution

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

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

public class Solution
{
}

class Apple
{
}

class Pineapple
{
}

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

public class Solution
{
   public class Apple
   {
   }

   public static class Pineapple
   {
   }
}

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

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

அதனால்தான் ஒவ்வொரு வகுப்பும் அது சேர்ந்த தொகுப்பின் குறிப்புடன் தொடங்க வேண்டும். உதாரணமாக

public class Solution
{
}

package com.codegym.tasks.task0001;

public class Solution
{
}

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