8 veelgemaakte fouten gemaakt door beginnende programmeurs

Objecten vergelijken met == .

De operator == vergelijkt objectreferenties.

Verwijzingen verwijzen naar adressen in het geheugen. Als ze op verschillende adressen zijn opgeslagen, levert vergelijking met == false op .

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

Om objecten te vergelijken, heeft de klasse Object een speciale methode: equals() . Eerlijk gezegd is de standaardimplementatie niet slecht:

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

In de klasse Object zelf wordt de methode equals() geïmplementeerd als een vergelijking van twee referenties. Om objecten correct te kunnen vergelijken, moet u deze methode opnieuw definiëren volgens de criteria die relevant zijn in uw specifieke programma voor uw specifieke objecten. De criteria voor gelijkheid zijn aan jou.

Het enige dat u niet mag vergeten, is de lijst met vereisten voor het correct overschrijven van equals() . Je kunt ze gemakkelijk vinden op internet.

Niet-statische variabelen gebruiken in statische methoden (en vice versa).

Als je ooit het bericht hebt gezien "Niet-statische variabele x kan niet worden verwezen vanuit een statische context", welkom bij de club :)

Statische methoden hebben geen toegang tot niet-statische (instantie)variabelen.

Dit is logisch: een statische methode kan immers worden aangeroepen zonder een object van zijn klasse te maken, en alle velden behoren tot specifieke objecten. En hierin ligt de tegenstrijdigheid die de fout veroorzaakt.

Trouwens, de andere kant op werkt prima: je kunt statische variabelen gebruiken in niet-statische methoden:

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

Onjuist begrip van hoe argumenten worden doorgegeven aan methoden: door verwijzing of door waarde.

Objecten en primitieven worden op twee verschillende manieren aan methoden doorgegeven: ten eerste door verwijzing; ten tweede op waarde.

Beginners vinden het vaak moeilijk om dit concept te begrijpen. Als gevolg hiervan gedraagt ​​hun code zich onverwacht:

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

Als je niet precies weet welk getal zal toenemen en welk niet (het gewone oude getal of de leeftijd van de kat), lees dan onze les over het onderwerp opnieuw .

Codeerregels negeren.

Dit geldt niet alleen voor de naleving van bepaalde "technische" principes, maar ook voor alledaagse naamgevingsconventies.

Al deze regels (hoe variabelen te benoemen, hoe methodenamen te schrijven) zijn met een reden bedacht. Ze hebben echt invloed op de leesbaarheid van code

De code is immers niet altijd alleen van jou. Het kan zijn dat u wordt overgeplaatst naar een ander project binnen uw bedrijf. Uw collega's die uw code erven, zullen uiteraard niet blij zijn als ze zoiets zien:

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

Uw code kan ingenieus hoge prestaties hebben, maar als het onmogelijk is om te lezen en te begrijpen hoe het werkelijk werkt, dan is het helaas niet veel waard.

Als je je aan de coderingsnormen houdt, zullen je meer ervaren collega's je in ieder geval kunnen vertellen hoe het vanuit technisch oogpunt kan worden verbeterd, zelfs als je code verre van ideaal is :)

Misverstand van de klasse String

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

Als je niet weet waarom deze code false weergeeft , moet je natuurlijk je kennis vergroten :)

Beginners zijn zich vaak niet bewust van de String Pool en hoe deze werkt.

Als gevolg hiervan begrijpen ze niet helemaal hoe ze strings in hun code goed kunnen vergelijken. In een van onze lessen zijn we uitgebreid op dit onderwerp ingegaan .

Uitzonderingen verkeerd afhandelen.

Beginners zijn niet de enigen die hierover struikelen. Ervaren ontwikkelaars struikelen ook. De redenen zijn talrijk.

Ten eerste is er geen universeel recept. Programma's hebben allerlei verschillende fouten en verschillende foutafhandelingsscenario's.

Ten tweede begrijpt niet iedereen hoe een stacktracering is gestructureerd. Er zijn veel antipatronen voor het afhandelen van fouten, en elk ervan is op zijn eigen manier "fout". Dit betekent dat het veel gemakkelijker is om foutafhandeling verkeerd te krijgen dan zo ongeveer iets anders.

Niet volledig begrijpen hoe operators (rekenkundig, logisch en andere) werken.

Hier is een eenvoudig voorbeeld. Kun je meteen zien wat deze code zal weergeven?

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

Als je fout hebt geantwoord of het gewoon hebt geraden, dan heb je nog steeds kennislacunes op dit gebied :)

De code geeft false weer , omdat de gelijkheidsoperator ( == ) een hogere prioriteit heeft dan de postfix-incrementoperator ( ++ ). Daarom wordt eerst de 7 == i- vergelijking uitgevoerd en pas daarna wordt de i++- bewerking uitgevoerd.

We hebben hier trouwens ook een uitgebreide les over gehad. Hier is de link als je die gemist hebt.

Het weglaten van het woordeinde in een switch- instructie.

Veel mensen die dit artikel lezen, hebben zeker deze fout gemaakt! :)

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

Als gevolg hiervan tuimelt de uitvoering door elke mogelijke optie:

Uitgang:

Het getal is gelijk aan 1 Het getal is gelijk aan 2 Het getal is gelijk aan 3

Een break- instructie onderbreekt de uitvoering van de switch- instructie wanneer een van de opties wordt uitgevoerd. Vergeet het niet, anders krijg je onverwachte resultaten :)