Most Common Mistakes Made By An Inexperienced Programmer Or Developer

String name = "ravi";
String newName = "ravi";
System.out.println(name==newName); --> true

String mynewName = new String("ravi");
System.out.println(name==mynewName); --> false
System.out.println(name.equals(mynewName)); -->true 

public class Cat {
    private String name;
    public Cat(String name) {
        this.name = name;
    }
    public static void main(String[] args) throws Throwable {
        Cat cat1 = new Cat("lilly");
        Cat cat2 = new Cat("lilly");
        System.out.println(cat1 == cat2);
        -- > false
        System.out.println(cat1.name.equals(cat2.name));
        -- > true
    }
}

4. Use of Static and non-static variable

The beginner always muddles in static and non-static contexts. So here is a simple difference, when a class is loaded into memory a static object is created immediately. This object stores static class variables (static class fields). The static object exists even if no ordinary (non-static) objects of the class have been created.

Ordinary variables of a class are bound to objects of the class (instances of the class), while static variables are bound to the class's static object.

The static method can't use the non-static variable. 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. but you can use static variables in non-static methods:

class Solution3 {
    public int a = 1;
    public static int staticVar = 2;
    public static void main(String[] args) {
        System.out.println(a); // Non-static field 'a' cannot be referenced from a static context 
    }
    public void useStatic() {
        System.out.println(staticVar); // This is acceptable!
    }
}

5. Removing elements from an ArrayList

After removing an element from the ArrayList its size is affected dynamically and the positions of the remaining elements immediately change.

Let's assume you have 10 elements in the list and you have to remove 3 last from the list.

Here's how to do that incorrectly:

ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 1; i <= 10; i++)
        list.add(i);
int n = list.size();
list.remove(n - 3); n=10 , ->7 removed size 9
list.remove(n - 2); n= 9 , ->8 removed size 8
list.remove(n - 1); n= 8, ->9 removed size 7 (ERROR size is 7 but removing 9th element)

Assume this is like a plate over plates that will be shifted just after the removal of anyone.

There is two correct way to do that, first remove from the end of the list or use the size-number of the element want to remove from the list

list.remove(n - 1);
list.remove(n - 2);
list.remove(n - 3);

or

list.remove(n - 3);
list.remove(n - 3);
list.remove(n - 3);

6. Call by reference and call by value

There are two types of variables in java that is primitive and non-primitive. If you pass primitive data then is called call by value and if you pass non-primitive data to the method then it is called call by reference.

Newbies often find it difficult to understand this concept. As a result, their code behaves unexpectedly. Let's understand both by example

Call by value

public class TimeMachine {
    public void goToPast(int currentYear) {
        System.out.println("The goToPast method has started running!");
        System.out.println("currentYear inside the goToPast method (at the beginning) = " + currentYear);
        currentYear = currentYear - 10;
        System.out.println("currentYear inside the goToPast method (at the end) = " + currentYear);
    }
    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        int currentYear = 2018;
        System.out.println("What was the year when the program started?");
        System.out.println(currentYear);
        timeMachine.goToPast(currentYear);
        System.out.println("And what year is it now?");
        System.out.println(currentYear);
    }
}

Output

What was the year when the program started?
2018

The goToPast method has started running!

currentYear inside the goToPast method (at the beginning) = 2018
currentYear inside the goToPast method (at the end) = 2008

And what year is it now?
2018

Call by reference

public class TimeMachine {
    public static class Cat {
        int age;
        public Cat(int age) {
            this.age = age;
        }
    }
    public void goToFuture(Cat cat) {
        cat.age += 10;
    }
    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        Cat smudge = new Cat(5);
        System.out.println("How old was Smudge when the program started?");
        System.out.println(smudge.age);
        timeMachine.goToFuture(smudge);
        System.out.println("How about now?");
        System.out.println(smudge.age);
    }
}

Output

How old was Smudge when the program started?
5

How about now?
15

Summary

In this article, we have covered the most common mistakes made by programmers and how we can overcome them. You can comment on any suggestion in this article below.

Thank you, Happy learning.......