புதிய புரோகிராமர்கள் செய்யும் 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

ஒரு பிரேக் ஸ்டேட்மென்ட் , விருப்பங்களில் ஒன்றைச் செயல்படுத்தும்போது, ​​சுவிட்ச் ஸ்டேட்மெண்ட் செயல்படுத்தப்படுவதைத் தடுக்கிறது . அதை மறந்துவிடாதீர்கள் அல்லது நீங்கள் எதிர்பாராத முடிவுகளைப் பெறலாம் :)