జనాదరణ పొందిన సంకలన లోపాలు

"హే, యువ నియామకం, ప్రతిరోజు చాలా సాధారణ ప్రోగ్రామ్‌లలో కూడా తప్పులు చేసేవాడు!

"అమ్మో... హాయ్, డియెగో. అబ్బాయి, ప్రజలను ఎలా ఉత్సాహపరచాలో నీకు నిజంగా తెలుసు!"

"అయితే, నేను చేస్తాను! చెప్పవలసినది ఎలా చెప్పాలో నేర్చుకోండి. నేను చెప్పినట్లు, 'ప్రతిరోజూ' ."

"ఓహ్, అప్పుడు ధన్యవాదాలు, నా అత్యంత లోహ గురువు! .

"ఈ పాఠం తర్వాత మీరు నాకు కృతజ్ఞతలు తెలుపుతారు. ఇక్కడ నేను కంపైలర్ ద్వారా గుర్తించబడిన అత్యంత జనాదరణ పొందిన లోపాలను జాబితా చేయబోతున్నాను. మరియు మీ పని గుర్తుంచుకోవాలి. ఫోర్‌వార్న్డ్ అనేది ముంజేయి.

సెమికోలన్‌ను మర్చిపోవడం

"జావా ప్రోగ్రామర్లు ఔత్సాహికులు చేసే అత్యంత సాధారణ పొరపాటు సెమికోలన్‌ను కలిగి ఉంటుంది. లేకుంటే, అది ఎక్కడ ఉండకూడదు."

"నిజం ఏమిటంటే.. నేను ఈ నేరాన్ని పదేపదే చేశాను."

"మెథడ్‌లోని ప్రతి స్టేట్‌మెంట్ సెమికోలన్‌తో ముగియాలి. సెమికోలన్ అనేది స్టేట్‌మెంట్‌లు లేదా కమాండ్‌లను వేరు చేస్తుంది: ఈ విధంగా మనం జావా కంపైలర్‌కి ఒక కమాండ్ ముగుస్తుంది మరియు తదుపరిది ప్రారంభమవుతుంది.

లోపాల ఉదాహరణలు:

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మరియు మీ ప్రోగ్రామ్ కంపైల్ చేయదు."

"ధన్యవాదాలు, డియెగో. ఈ పాఠం నన్ను మరింత శ్రద్ధగా చూసేలా చేస్తుంది."

"అదే నేను లెక్కపెట్టాను. గుడ్ లక్!"