8 טעויות נפוצות שנעשו על ידי מתכנתים טירונים

השוואת אובייקטים באמצעות == .

האופרטור == משווה הפניות לאובייקט.

הפניות מצביעות על כתובות בזיכרון. אם הם מאוחסנים בכתובות שונות, אז השוואה באמצעות == תחזיר false .

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

כדי להשוות אובייקטים, למחלקה Object יש שיטה מיוחדת: equals() . למען האמת, יישום ברירת המחדל שלו לא רע:

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

במחלקה Object עצמה, שיטת equals() מיושמת כהשוואה של שני הפניות. בתורו, על מנת להשוות נכון בין אובייקטים, עליך להגדיר מחדש שיטה זו בהתאם לקריטריונים הרלוונטיים בתוכנית הספציפית שלך עבור האובייקטים הספציפיים שלך. הקריטריונים לשוויון תלויים בך.

הדבר היחיד שאסור לשכוח הוא רשימת הדרישות לעקיפה נכונה של equals() . אתה יכול למצוא אותם בקלות באינטרנט.

שימוש במשתנים לא סטטיים בשיטות סטטיות (ולהיפך).

אם אי פעם ראית את ההודעה "לא ניתן להתייחס למשתנה לא סטטי 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++);
    }
}

אם עניתם לא נכון או סתם ניחשתם, אז עדיין יש לכם פערי ידע בתחום הזה :)

הקוד יציג false , כי לאופרטור השוויון ( == ) יש עדיפות גבוהה יותר מאופרטור תוספת התיקון ( ++ ). לכן, ההשוואה 7 == i נמחקת תחילה, ורק לאחר מכן מתבצעת פעולת i++ .

אגב, גם על זה היה לנו שיעור מפורט. הנה הקישור אם פספסת.

השמטת המילה break בהצהרת switch .

אנשים רבים שקוראים מאמר זה בהחלט עשו את הטעות הזו! :)

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

הצהרת break קוטעת את ביצוע הצהרת ה-switch כאשר אחת האפשרויות מסתיימת בביצוע. אל תשכח את זה או שאתה עלול לקבל תוצאות בלתי צפויות :)