8 erreurs courantes commises par les programmeurs débutants

Comparer des objets en utilisant == .

L' opérateur == compare les références d'objet.

Les références pointent vers des adresses en mémoire. S'ils sont stockés à des adresses différentes, la comparaison avec == renverra 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);
    }
}

Pour comparer des objets, la classe Object a une méthode spéciale : equals() . Franchement, son implémentation par défaut n'est pas mauvaise :

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

Dans la classe Object elle-même, la méthode equals() est implémentée comme une comparaison de deux références. À son tour, afin de comparer correctement les objets, vous devez redéfinir cette méthode en fonction des critères pertinents dans votre programme particulier pour vos objets particuliers. Les critères d'égalité vous appartiennent.

La seule chose que vous ne devez pas oublier est la liste des exigences pour remplacer correctement equals() . Vous pouvez facilement les trouver sur Internet.

Utilisation de variables non statiques dans des méthodes statiques (et vice versa).

Si vous avez déjà vu le message "La variable non statique x ne peut pas être référencée à partir d'un contexte statique", bienvenue dans le club :)

Les méthodes statiques n'ont pas accès aux variables non statiques (d'instance).

Cela a du sens : après tout, une méthode statique peut être appelée sans créer d'objet de sa classe, et tous les champs appartiennent à des objets spécifiques. Et c'est là que réside la contradiction qui cause l'erreur.

Au fait, aller dans l'autre sens fonctionne bien : vous pouvez utiliser des variables statiques dans des méthodes non statiques :

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

Incompréhension de la façon dont les arguments sont passés aux méthodes : par référence ou par valeur.

Les objets et les primitives sont passés aux méthodes de deux manières différentes : premièrement, par référence ; deuxièmement, en valeur.

Les débutants ont souvent du mal à comprendre ce concept. En conséquence, leur code se comporte de manière inattendue :

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

Si vous ne savez pas exactement quel nombre augmentera et lequel ne le fera pas (l'ancien nombre ou l'âge du chat), alors relisez notre leçon sur le sujet .

Ignorer les règles de codage.

Cela s'applique non seulement au respect de certains principes "techniques", mais également aux conventions de nommage banales.

Toutes ces règles (comment nommer les variables, comment écrire les noms des méthodes) ont été inventées pour une raison. Ils affectent vraiment la lisibilité du code

Après tout, le code ne sera pas toujours à vous seul. Vous pourriez être transféré à un autre projet de votre entreprise. Vos collègues qui héritent de votre code ne seront évidemment pas contents quand ils verront quelque chose comme ça :

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

Votre code peut avoir des performances ingénieusement élevées, mais s'il est impossible de lire et de comprendre comment il fonctionne réellement, alors, hélas, cela ne vaut pas grand-chose.

Si vous vous en tenez aux normes de codage, alors même si votre code est loin d'être idéal, au moins vos collègues plus expérimentés pourront vous dire comment il peut être amélioré d'un point de vue technique :)

Incompréhension de la 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);
    }
}

Si vous ne savez pas pourquoi ce code affiche false , vous devez évidemment renforcer vos connaissances :)

Les débutants ne connaissent souvent pas le String Pool et son fonctionnement.

Par conséquent, ils ne comprennent pas entièrement comment comparer correctement les chaînes dans leur code. Nous avons exploré ce sujet en détail dans l'une de nos leçons .

Gestion incorrecte des exceptions.

Les débutants ne sont pas les seuls à tomber dessus. Les développeurs expérimentés se font aussi trébucher. Les raisons sont nombreuses.

D'abord, il n'y a pas de recette universelle. Les programmes ont toutes sortes d'erreurs différentes et différents scénarios de gestion des erreurs.

Deuxièmement, tout le monde ne comprend pas comment une trace de pile est structurée. Il existe de nombreux antimodèles de gestion des erreurs, et chacun d'eux est "faux" à sa manière. Cela signifie qu'il est beaucoup plus facile de mal gérer les erreurs que n'importe quoi d'autre.

Ne pas bien comprendre le fonctionnement des opérateurs (arithmétiques, logiques et autres).

Voici un exemple simple. Pouvez-vous dire tout de suite ce que ce code affichera ?

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

Si vous avez mal répondu ou simplement deviné, alors vous avez encore des lacunes dans ce domaine :)

Le code affichera false , car l'opérateur d'égalité ( == ) a une priorité plus élevée que l'opérateur d'incrémentation suffixe ( ++ ). Par conséquent, la comparaison 7 == i est exécutée en premier, et ensuite seulement l' opération i++ est effectuée.

Soit dit en passant, nous avons également eu une leçon détaillée à ce sujet. Voici le lien si vous l'avez manqué.

Omettre le mot break dans une instruction switch .

Beaucoup de personnes lisant cet article ont certainement fait cette erreur ! :)

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

En conséquence, l'exécution passe par toutes les options possibles :

Sortir:

Le nombre est égal à 1 Le nombre est égal à 2 Le nombre est égal à 3

Une instruction break interrompt l'exécution de l' instruction switch lorsqu'une des options a fini d'être exécutée. Ne l'oubliez pas ou vous pourriez obtenir des résultats inattendus :)