8 errori comuni commessi dai programmatori alle prime armi

Confronto di oggetti utilizzando == .

L' operatore == confronta i riferimenti agli oggetti.

I riferimenti puntano agli indirizzi in memoria. Se sono archiviati in indirizzi diversi, il confronto utilizzando == restituirà 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);
    }
}

Per confrontare gli oggetti, la classe Object ha un metodo speciale: equals() . Francamente, la sua implementazione predefinita non è male:

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

Nella stessa classe Object , il metodo equals() è implementato come confronto tra due riferimenti. A sua volta, per confrontare correttamente gli oggetti, è necessario ridefinire questo metodo in base ai criteri rilevanti nel proprio programma specifico per i propri oggetti particolari. I criteri per l'uguaglianza dipendono da te.

L'unica cosa che non devi dimenticare è l'elenco dei requisiti per sovrascrivere correttamente equals() . Puoi trovarli facilmente su Internet.

Utilizzo di variabili non statiche nei metodi statici (e viceversa).

Se hai mai visto il messaggio "Non è possibile fare riferimento alla variabile x non statica da un contesto statico", benvenuto nel club :)

I metodi statici non hanno accesso alle variabili (istanza) non statiche.

Questo ha senso: dopotutto, un metodo statico può essere chiamato senza creare un oggetto della sua classe e tutti i campi appartengono a oggetti specifici. E qui sta la contraddizione che causa l'errore.

A proposito, andare dall'altra parte funziona bene: puoi usare variabili statiche in metodi non statici:

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

Fraintendimento del modo in cui gli argomenti vengono passati ai metodi: per riferimento o per valore.

Gli oggetti e le primitive vengono passati ai metodi in due modi diversi: primo, per riferimento; secondo, per valore.

I principianti spesso trovano difficile comprendere questo concetto. Di conseguenza, il loro codice si comporta in modo imprevisto:

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

Se non sai esattamente quale numero aumenterà e quale no (il semplice vecchio numero o l'età del gatto), allora rileggi la nostra lezione sull'argomento .

Ignorando le regole di codifica.

Ciò vale non solo per il rispetto di determinati principi "tecnici", ma anche per banali convenzioni di denominazione.

Tutte queste regole (come denominare le variabili, come scrivere i nomi dei metodi) sono state inventate per un motivo. Influiscono veramente sulla leggibilità del codice

Dopotutto, il codice non sarà sempre solo tuo. Potresti essere trasferito a un altro progetto della tua azienda. I tuoi colleghi che ereditano il tuo codice ovviamente non saranno contenti quando vedranno qualcosa del genere:

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

Il tuo codice potrebbe avere prestazioni ingegnosamente elevate, ma se è impossibile leggerlo e capire come funziona effettivamente, allora, ahimè, non vale molto.

Se ti attieni agli standard di codifica, anche se il tuo codice è tutt'altro che ideale, almeno i tuoi colleghi più esperti saranno in grado di dirti come può essere migliorato dal punto di vista tecnico :)

Fraintendimento della classe 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);
    }
}

Se non sai perché questo codice visualizza false , devi ovviamente rafforzare le tue conoscenze :)

I principianti spesso non sono a conoscenza dello String Pool e di come funziona.

Di conseguenza, non capiscono del tutto come confrontare correttamente le stringhe nel loro codice. Abbiamo approfondito questo argomento in una delle nostre lezioni .

Gestione errata delle eccezioni.

I principianti non sono gli unici che si imbattono in questo. Anche gli sviluppatori esperti vengono inciampati. I motivi sono tanti.

Innanzitutto, non esiste una ricetta universale. I programmi hanno tutti i tipi di errori diversi e diversi scenari di gestione degli errori.

In secondo luogo, non tutti comprendono come è strutturata una traccia dello stack . Esistono molti antipattern di gestione degli errori e ognuno di essi è "sbagliato" a modo suo. Ciò significa che è molto più facile sbagliare la gestione degli errori rispetto a qualsiasi altra cosa.

Non comprendere appieno come funzionano gli operatori (aritmetici, logici e altri).

Ecco un semplice esempio. Puoi dire subito cosa visualizzerà questo codice?

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

Se hai risposto in modo errato o hai solo indovinato, hai ancora lacune di conoscenza in quest'area :)

Il codice visualizzerà false , perché l'operatore di uguaglianza ( == ) ha una priorità maggiore rispetto all'operatore di incremento suffissa ( ++ ). Pertanto, il confronto 7 == i viene eseguito per primo e solo successivamente viene eseguita l' operazione i++ .

A proposito, abbiamo avuto anche una lezione dettagliata su questo. Ecco il link se ve lo siete perso.

Omissione della parola break in un'istruzione switch .

Molte persone che leggono questo articolo hanno sicuramente commesso questo errore! :)

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

Di conseguenza, l'esecuzione passa attraverso ogni possibile opzione:

Produzione:

Il numero è uguale a 1 Il numero è uguale a 2 Il numero è uguale a 3

Un'istruzione break interrompe l'esecuzione dell'istruzione switch al termine dell'esecuzione di una delle opzioni. Non dimenticarlo o potresti ottenere risultati inaspettati :)