8 common mistakes made by rookie programmers

Comparing objects using ==.

The == operator compares object references.

References point to addresses in memory. If they are stored at different addresses, then comparison using == will return 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);
    }
}

To compare objects, the Object class has a special method: equals(). Frankly, its default implementation is not bad:

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

In the Object class itself, the equals() method is implemented as a comparison of two references. In turn, in order to correctly compare objects, you need to redefine this method according to the criteria that are relevant in your particular program for your particular objects. The criteria for equality are up to you.

The only thing you must not forget is the list of requirements for properly overriding equals(). You can easily find them on the Internet.

Using non-static variables in static methods (and vice versa).

If you've ever seen the message "Non-static variable x cannot be referenced from a static context", welcome to the club :)

Static methods don't have access to non-static (instance) variables.

This makes sense: after all, a static method can be called without creating an object of its class, and all fields belong to specific objects. And herein lies the contradiction that causes the error.

By the way, going the other way works fine: you can use static variables in non-static methods:

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

Misunderstanding how arguments are passed to methods: by reference or by value.

Objects and primitives are passed to methods in two different ways: first, by reference; second, by value.

Beginners often find it difficult to understand this concept. As a result, their code behaves unexpectedly:

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

If you don't know exactly which number will increase and which will not (the plain old number or the cat's age), then re-read our lesson on the topic.

Ignoring coding rules.

This applies not only to compliance with certain "technical" principles, but also to mundane naming conventions.

All these rules (how to name variables, how to write method names) were invented for a reason. They truly affect the readability of code

After all, the code will not always be yours alone. You might be transferred to a different project at your company. Your coworkers who inherit your code will obviously not be happy when they see something like this:

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;

}

Your code might have ingeniously high performance, but if it is impossible to read and understand how it actually works, then, alas, it isn't worth much.

If you stick to coding standards, then even if your code is far from ideal, at least your more experienced coworkers will be able to tell you how it can be improved from a technical point of view :)

Misunderstanding the String class

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

If you don't know why this code displays false, you obviously need to beef up your knowledge :)

Beginners are often unaware of the String Pool and how it works.

As a result, they do not entirely understand how to properly compare strings in their code. We explored this topic in detail in one of our lessons.

Handling exceptions incorrectly.

Beginners aren't the only ones who stumble on this. Experienced developers get tripped up too. The reasons are many.

First, there is no universal recipe. Programs have all sorts of different errors and different error handling scenarios.

Second, not everyone understands how a stack trace is structured. There are a lot of error handling antipatterns, and each of them is "wrong" in its own way. This means that it's a lot easier to get error handling wrong than just about anything else.

Not fully understanding how operators (arithmetic, logical and others) work.

Here's a simple example. Can you tell right away what this code will display?

public class Main {

    public static void main(String[] args) {

        int i = 6;
        System.out.println(7 == i++);
    }
}

If you answered incorrectly or just guessed, then you still have knowledge gaps in this area :)

The code will display false. Therefore, the 7 == i comparison is excuted first, and only then is the i++ operation performed.

By the way, we also had a detailed lesson on this. Here's the link if you missed it.

Omitting the word break in a switch statement.

Many people reading this article have certainly made this mistake! :)

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

As a result, execution tumbles through every possible option:

Output:

The number is equal to 1
The number is equal to 2
The number is equal to 3

A break statement interrupts execution of the switch statement when one of the options is done being executed. Don't forget it or you may get unexpected results :)