8 gyakori hiba, amelyet újonc programozók követnek el

Objektumok összehasonlítása == használatával .

Az == operátor összehasonlítja az objektumhivatkozásokat.

A hivatkozások a memóriában lévő címekre mutatnak. Ha különböző címeken vannak tárolva, akkor az == használatával történő összehasonlítás false értéket ad vissza .

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

Az objektumok összehasonlításához az Object osztálynak van egy speciális metódusa: equals() . Őszintén szólva az alapértelmezett megvalósítás nem rossz:

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

Magában az Object osztályban az equals() metódus két hivatkozás összehasonlításaként valósul meg. Az objektumok helyes összehasonlítása érdekében viszont újra kell definiálni ezt a módszert az adott programban az adott objektumokra vonatkozó kritériumoknak megfelelően. Az egyenlőség kritériumai rajtad múlik.

Az egyetlen dolog, amit nem szabad elfelejteni, az az egyenlőség() megfelelő felülbírálásához szükséges követelmények listája . Könnyen megtalálhatja őket az interneten.

Nem statikus változók használata statikus módszerekben (és fordítva).

Ha láttad már a "Nem statikus x változóra nem lehet statikus kontextusból hivatkozni" üzenetet, üdv a klubban :)

A statikus metódusok nem férnek hozzá a nem statikus (példány) változókhoz.

Ez logikus: végül is egy statikus metódus meghívható anélkül, hogy az osztályába tartozó objektumot létrehoznánk, és minden mező meghatározott objektumokhoz tartozik. És itt rejlik az ellentmondás, ami a hibát okozza.

Egyébként a másik irányba haladva jól működik: használhat statikus változókat a nem statikus módszerekben:

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!
    }
}

Félreértés, hogyan adják át az argumentumokat a metódusoknak: hivatkozással vagy értékkel.

Az objektumok és a primitívek két különböző módon kerülnek átadásra a metódusoknak: először is, hivatkozással; másodszor, érték szerint.

A kezdőknek gyakran nehéz megérteni ezt a fogalmat. Ennek eredményeként a kódjuk váratlanul viselkedik:

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

Ha nem tudja pontosan, hogy melyik szám fog növekedni és melyik nem (a sima régi szám vagy a macska életkora), akkor olvassa el újra a témával kapcsolatos leckét .

A kódolási szabályok figyelmen kívül hagyása.

Ez nemcsak bizonyos "technikai" elvek betartására vonatkozik, hanem a hétköznapi elnevezési konvenciókra is.

Mindezeket a szabályokat (változók elnevezése, metódusnevek írása) okkal találták ki. Valóban befolyásolják a kód olvashatóságát

Végtére is, a kód nem mindig az Öné lesz. Előfordulhat, hogy áthelyeznek egy másik projektbe a cégénél. Munkatársaid, akik öröklik a kódodat, nyilvánvalóan nem fognak örülni, ha valami ilyesmit látnak:

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

Lehet, hogy a kódod zseniálisan nagy teljesítményű, de ha lehetetlen elolvasni és megérteni, hogyan működik valójában, akkor sajnos nem sokat ér.

Ha ragaszkodsz a kódolási szabványokhoz, akkor még ha a kódod távolról sem ideális, legalább a tapasztaltabb munkatársaid meg tudják mondani, hogyan lehetne technikailag javítani :)

A String osztály félreértése

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

Ha nem tudod, hogy ez a kód miért hamis , akkor nyilván erősíteni kell tudásodat :)

A kezdők gyakran nincsenek tisztában a String Pool- val és annak működésével.

Ennek eredményeként nem teljesen értik, hogyan kell megfelelően összehasonlítani a karakterláncokat a kódjukban. Ezt a témát részletesen megvizsgáltuk egyik leckénkben .

A kivételek helytelen kezelése.

Nem csak a kezdők botlanak ezen. A tapasztalt fejlesztők is megbotlanak. Az okok sokak.

Először is, nincs univerzális recept. A programok mindenféle hibával és különböző hibakezelési forgatókönyvekkel rendelkeznek.

Másodszor, nem mindenki érti, hogyan épül fel a veremnyom . Nagyon sok hibakezelési antiminta létezik, és mindegyik „hibás” a maga módján. Ez azt jelenti, hogy sokkal könnyebb elhibázni a hibakezelést, mint bármi mást.

Nem érti teljesen az operátorok (aritmetikai, logikai és mások) működését.

Íme egy egyszerű példa. Meg tudod mondani azonnal, hogy ez a kód mit fog megjeleníteni?

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

Ha rosszul válaszoltál, vagy csak sejtetted, akkor még mindig vannak hiányosságaid ezen a téren :)

A kód false értékű lesz , mivel az egyenlőség operátor ( == ) magasabb prioritású, mint a postfix növekmény operátor ( ++ ). Ezért először a 7 == i összehasonlítást hajtjuk végre, és csak ezután hajtjuk végre az i++ műveletet.

Erről egyébként volt egy részletes leckénk is. Itt a link , ha lemaradtál róla.

A break szó elhagyása a switch utasításban.

Sokan ezt a cikket olvassák biztosan elkövették ezt a hibát! :)

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

Ennek eredményeként a végrehajtás minden lehetséges opción átesik:

Kimenet:

A szám egyenlő 1-gyel A szám egyenlő 2-vel A szám egyenlő 3-mal

A break utasítás megszakítja a switch utasítás végrehajtását, amikor az egyik opció végrehajtása befejeződött. Ne felejtsd el, különben váratlan eredményeket érhetsz el :)