రూకీ ప్రోగ్రామర్లు చేసే 8 సాధారణ తప్పులు

== ఉపయోగించి వస్తువులను పోల్చడం .

== ఆపరేటర్ ఆబ్జెక్ట్ రిఫరెన్స్‌లను పోలుస్తుంది.

రిఫరెన్స్‌లు మెమరీలోని చిరునామాలను సూచిస్తాయి. అవి వేర్వేరు చిరునామాలలో నిల్వ చేయబడితే, == ఉపయోగించి పోల్చడం తప్పు అని తిరిగి వస్తుంది .

public class Vehicle {
 
    String model;
    int maxSpeed;
    int yearOfManufacture;
 
    public Car(String model, int maxSpeed, int yearOfManufacture) {
        this.model = model;
        this.maxSpeed = maxSpeed;
        this.yearOfManufacture = yearOfManufacture;
    }
 
    public static void main(String[] args) {
        Car ferrari = new Car("Ferrari 360 Spider", 280, 1996);
        Car ferrariTwin = new Car("Ferrari 360 Spider", 280, 1996);
        System.out.println(ferrari == ferrariTwin);
    }
}

ఆబ్జెక్ట్‌లను పోల్చడానికి, ఆబ్జెక్ట్ క్లాస్‌కు ప్రత్యేక పద్ధతి ఉంది: సమానం() . స్పష్టముగా, దాని డిఫాల్ట్ అమలు చెడ్డది కాదు:

public boolean equals(Object obj) {
    return (this == obj);
}

ఆబ్జెక్ట్ క్లాస్‌లోనే, ఈక్వల్స్() పద్ధతి రెండు సూచనల పోలికగా అమలు చేయబడుతుంది . ప్రతిగా, వస్తువులను సరిగ్గా సరిపోల్చడానికి, మీరు మీ నిర్దిష్ట వస్తువుల కోసం మీ నిర్దిష్ట ప్రోగ్రామ్‌లో సంబంధిత ప్రమాణాల ప్రకారం ఈ పద్ధతిని పునర్నిర్వచించవలసి ఉంటుంది. సమానత్వానికి ప్రమాణాలు మీ ఇష్టం.

మీరు మరచిపోకూడని ఏకైక విషయం ఏమిటంటే ఈక్విల్స్()ని సరిగ్గా భర్తీ చేయడానికి అవసరమైన జాబితా . మీరు వాటిని ఇంటర్నెట్‌లో సులభంగా కనుగొనవచ్చు.

స్టాటిక్ పద్ధతుల్లో నాన్-స్టాటిక్ వేరియబుల్స్ ఉపయోగించడం (మరియు వైస్ వెర్సా).

"నాన్-స్టాటిక్ వేరియబుల్ x స్టాటిక్ కాంటెక్స్ట్ నుండి సూచించబడదు" అనే సందేశాన్ని మీరు ఎప్పుడైనా చూసినట్లయితే, క్లబ్‌కు స్వాగతం :)

స్టాటిక్ పద్ధతులకు నాన్-స్టాటిక్ (ఉదాహరణ) వేరియబుల్స్‌కు యాక్సెస్ లేదు.

ఇది అర్ధమే: అన్నింటికంటే, దాని తరగతి యొక్క వస్తువును సృష్టించకుండా ఒక స్టాటిక్ పద్ధతిని పిలుస్తారు మరియు అన్ని ఫీల్డ్‌లు నిర్దిష్ట వస్తువులకు చెందినవి. మరియు ఇక్కడ లోపానికి కారణమయ్యే వైరుధ్యం ఉంది.

మార్గం ద్వారా, ఇతర మార్గంలో వెళ్లడం బాగా పని చేస్తుంది: మీరు స్టాటిక్ కాని పద్ధతులలో స్టాటిక్ వేరియబుల్‌లను ఉపయోగించవచ్చు:

public class Main {
 
    public int x = 10;
 
    public static int staticX = 100;
 
    public static void main(String[] args) {
 
        System.out.println(x); // Compilation error - you can't do this!
    }
 
    public void printX() {
 
        System.out.println(staticX); // But you can do this!
    }
}

వాదనలు పద్ధతులకు ఎలా పంపబడతాయో తప్పుగా అర్థం చేసుకోవడం: సూచన ద్వారా లేదా విలువ ద్వారా.

వస్తువులు మరియు ఆదిమాంశాలు రెండు విభిన్న మార్గాల్లో పద్ధతులకు పంపబడతాయి: మొదటిది, సూచన ద్వారా; రెండవది, విలువ ద్వారా.

ప్రారంభకులకు తరచుగా ఈ భావనను అర్థం చేసుకోవడం కష్టం. ఫలితంగా, వారి కోడ్ ఊహించని విధంగా ప్రవర్తిస్తుంది:

public class Main {
 
    public static void main(String[] args) {
 
        int x = 7;
        incrementNumber(x);
        System.out.println(x);
 
        Cat cat = new Cat(7);
        catLevelUp(cat);
        System.out.println(cat.getAge());
 
    }
 
    public static void catLevelUp(Cat cat) {
 
        cat.setAge(cat.getAge()+1);
    }
 
    public static void incrementNumber(int x) {
        x++;
    }
}

ఏ సంఖ్య పెరుగుతుందో మరియు ఏది పెరగదని మీకు ఖచ్చితంగా తెలియకపోతే (సాదా పాత సంఖ్య లేదా పిల్లి వయస్సు), ఆపై అంశంపై మా పాఠాన్ని మళ్లీ చదవండి .

కోడింగ్ నియమాలను విస్మరించడం.

ఇది కొన్ని "సాంకేతిక" సూత్రాలకు అనుగుణంగా మాత్రమే కాకుండా, ప్రాపంచిక నామకరణ సంప్రదాయాలకు కూడా వర్తిస్తుంది.

ఈ నియమాలన్నీ (వేరియబుల్స్‌కు ఎలా పేరు పెట్టాలి, పద్ధతి పేర్లను ఎలా వ్రాయాలి) ఒక కారణం కోసం కనుగొనబడ్డాయి. అవి కోడ్ యొక్క రీడబిలిటీని నిజంగా ప్రభావితం చేస్తాయి

అన్నింటికంటే, కోడ్ ఎల్లప్పుడూ మీదే కాదు. మీరు మీ కంపెనీలో వేరే ప్రాజెక్ట్‌కి బదిలీ చేయబడవచ్చు. మీ కోడ్‌ను వారసత్వంగా పొందిన మీ సహోద్యోగులు ఇలాంటివి చూసినప్పుడు సంతోషంగా ఉండరు:

public class Cat {
 
    private int S_O_M_E_T_H_I_N_G = 7;
    public String striiiiiiiiiiiiiing;
    protected double I_HAVE_NO_IDEA_WHAT_THIS_IS = 3.14;
    boolean random = Math.random() > 0.5;
 
}

మీ కోడ్ తెలివిగా అధిక పనితీరును కలిగి ఉండవచ్చు, కానీ అది వాస్తవానికి ఎలా పనిచేస్తుందో చదవడం మరియు అర్థం చేసుకోవడం అసాధ్యం అయితే, అయ్యో, ఇది చాలా విలువైనది కాదు.

మీరు కోడింగ్ ప్రమాణాలకు కట్టుబడి ఉంటే, మీ కోడ్ ఆదర్శానికి దూరంగా ఉన్నప్పటికీ, కనీసం మీ మరింత అనుభవజ్ఞులైన సహోద్యోగులు సాంకేతిక కోణం నుండి దీన్ని ఎలా మెరుగుపరచవచ్చో చెప్పగలరు :)

స్ట్రింగ్ క్లాస్‌ని తప్పుగా అర్థం చేసుకోవడం

public class Main {
 
    public static void main(String[] args) {
 
        String s1 = "I'm learning Java";
        String s2 = new String("I'm learning Java");
 
        System.out.println(s1 == s2);
    }
}

ఈ కోడ్ తప్పుగా ఎందుకు ప్రదర్శిస్తుందో మీకు తెలియకపోతే , మీరు స్పష్టంగా మీ జ్ఞానాన్ని పెంచుకోవాలి :)

ప్రారంభకులకు స్ట్రింగ్ పూల్ మరియు అది ఎలా పని చేస్తుందో తరచుగా తెలియదు.

ఫలితంగా, వారి కోడ్‌లోని తీగలను ఎలా సరిగ్గా సరిపోల్చాలో వారికి పూర్తిగా అర్థం కాలేదు. మేము మా పాఠాలలో ఒకదానిలో ఈ అంశాన్ని వివరంగా విశ్లేషించాము .

మినహాయింపులను తప్పుగా నిర్వహించడం.

బిగినర్స్ మాత్రమే ఈ విషయంలో పొరపాట్లు చేయరు. అనుభవజ్ఞులైన డెవలపర్లు కూడా ట్రిప్ అవుతారు. కారణాలు అనేకం.

మొదట, సార్వత్రిక వంటకం లేదు. ప్రోగ్రామ్‌లు అన్ని రకాల విభిన్న ఎర్రర్‌లను మరియు విభిన్న ఎర్రర్ హ్యాండ్లింగ్ దృశ్యాలను కలిగి ఉంటాయి.

రెండవది, స్టాక్ ట్రేస్ ఎలా నిర్మించబడుతుందో అందరికీ అర్థం కాదు. యాంటీప్యాటర్న్‌లను నిర్వహించడంలో చాలా లోపాలు ఉన్నాయి మరియు వాటిలో ప్రతి ఒక్కటి దాని స్వంత మార్గంలో "తప్పు". దీనర్థం ఏదైనా దాని గురించి కాకుండా దోష నిర్వహణ తప్పుగా పొందడం చాలా సులభం.

ఆపరేటర్లు (అరిథ్మెటిక్, లాజికల్ మరియు ఇతరులు) ఎలా పని చేస్తారో పూర్తిగా అర్థం కాలేదు.

ఇక్కడ ఒక సాధారణ ఉదాహరణ. ఈ కోడ్ ఏమి ప్రదర్శిస్తుందో మీరు వెంటనే చెప్పగలరా?

public class Main {
 
    public static void main(String[] args) {
 
        int i = 6;
        System.out.println(7 == i++);
    }
}

మీరు తప్పుగా సమాధానం ఇచ్చినట్లయితే లేదా ఊహించినట్లయితే, ఈ ప్రాంతంలో మీకు ఇంకా జ్ఞాన అంతరాలు ఉన్నాయి :)

కోడ్ తప్పును ప్రదర్శిస్తుంది , ఎందుకంటే సమానత్వ ఆపరేటర్ ( == ) పోస్ట్‌ఫిక్స్ ఇంక్రిమెంట్ ఆపరేటర్ ( ++ ) కంటే ఎక్కువ ప్రాధాన్యతను కలిగి ఉంటుంది. కాబట్టి, 7 == i పోలిక ముందుగా అమలు చేయబడుతుంది మరియు ఆ తర్వాత మాత్రమే i++ ఆపరేషన్ చేయబడుతుంది.

మార్గం ద్వారా, మేము దీనిపై వివరణాత్మక పాఠాన్ని కూడా కలిగి ఉన్నాము. మీరు మిస్ అయితే ఇక్కడ లింక్ ఉంది.

స్విచ్ స్టేట్‌మెంట్‌లో వర్డ్ బ్రేక్‌ను వదిలివేయడం .

ఈ కథనాన్ని చదివిన చాలా మంది వ్యక్తులు ఖచ్చితంగా ఈ తప్పు చేసారు! :)

public class Main {
 
    public static void main(String[] args) {
 
        int i = 1;
 
        switch (i) {
 
            case 1: {
                System.out.println("The number is equal to 1");
            }
            case 2: {
                System.out.println("The number is equal to 2");
            }
            case 3: {
                System.out.println("The number is equal to 3");
            }
        }
    }
 }

ఫలితంగా, సాధ్యమయ్యే ప్రతి ఎంపిక ద్వారా అమలు పడిపోతుంది:

అవుట్‌పుట్:

సంఖ్య 1కి సమానం సంఖ్య 2కి సమానం సంఖ్య 3కి సమానం

ఎంపికలలో ఒకదానిని అమలు చేయడం పూర్తయినప్పుడు స్విచ్ స్టేట్‌మెంట్ అమలుకు బ్రేక్ స్టేట్‌మెంట్ అంతరాయం కలిగిస్తుంది . దీన్ని మర్చిపోవద్దు లేదా మీరు ఊహించని ఫలితాలను పొందవచ్చు :)