8 errores comunes que cometen los programadores novatos

Comparando objetos usando == .

El operador == compara referencias de objetos.

Las referencias apuntan a direcciones en la memoria. Si se almacenan en direcciones diferentes, la comparación con == devolverá 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);
    }
}

Para comparar objetos, la clase Object tiene un método especial: equals() . Francamente, su implementación por defecto no es mala:

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

En la propia clase Object , el método equals() se implementa como una comparación de dos referencias. A su vez, para comparar objetos correctamente, debe redefinir este método de acuerdo con los criterios que son relevantes en su programa particular para sus objetos particulares. Los criterios de igualdad son tuyos.

Lo único que no debe olvidar es la lista de requisitos para anular correctamente equals() . Puedes encontrarlos fácilmente en Internet.

Uso de variables no estáticas en métodos estáticos (y viceversa).

Si alguna vez ha visto el mensaje "No se puede hacer referencia a la variable no estática x desde un contexto estático", bienvenido al club :)

Los métodos estáticos no tienen acceso a variables no estáticas (de instancia).

Esto tiene sentido: después de todo, se puede llamar a un método estático sin crear un objeto de su clase, y todos los campos pertenecen a objetos específicos. Y aquí radica la contradicción que provoca el error.

Por cierto, ir hacia el otro lado funciona bien: puedes usar variables estáticas en métodos no estáticos:

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

No entender cómo se pasan los argumentos a los métodos: por referencia o por valor.

Los objetos y las primitivas se pasan a los métodos de dos maneras diferentes: primero, por referencia; segundo, por valor.

A los principiantes a menudo les resulta difícil entender este concepto. Como resultado, su código se comporta de forma inesperada:

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 no sabe exactamente qué número aumentará y cuál no (el número simple o la edad del gato), vuelva a leer nuestra lección sobre el tema .

Ignorar las reglas de codificación.

Esto se aplica no solo al cumplimiento de ciertos principios "técnicos", sino también a las convenciones de nomenclatura mundanas.

Todas estas reglas (cómo nombrar variables, cómo escribir nombres de métodos) se inventaron por una razón. Realmente afectan la legibilidad del código.

Después de todo, el código no siempre será solo tuyo. Es posible que lo transfieran a un proyecto diferente en su empresa. Tus compañeros de trabajo que heredan tu código obviamente no estarán contentos cuando vean algo como esto:

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

Su código puede tener un rendimiento ingeniosamente alto, pero si es imposible leer y comprender cómo funciona realmente, entonces, por desgracia, no vale mucho la pena.

Si se adhiere a los estándares de codificación, incluso si su código está lejos de ser ideal, al menos sus compañeros de trabajo más experimentados podrán decirle cómo se puede mejorar desde un punto de vista técnico :)

Malinterpretando la clase 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 no sabe por qué este código muestra falso , obviamente necesita reforzar su conocimiento :)

Los principiantes a menudo desconocen el String Pool y cómo funciona.

Como resultado, no entienden del todo cómo comparar correctamente las cadenas en su código. Exploramos este tema en detalle en una de nuestras lecciones .

Manejo de excepciones incorrectamente.

Los principiantes no son los únicos que tropiezan con esto. Los desarrolladores experimentados también se equivocan. Las razones son muchas.

En primer lugar, no existe una receta universal. Los programas tienen todo tipo de errores diferentes y diferentes escenarios de manejo de errores.

En segundo lugar, no todos entienden cómo se estructura un seguimiento de pila . Hay muchos antipatrones de manejo de errores, y cada uno de ellos es "incorrecto" a su manera. Esto significa que es mucho más fácil equivocarse en el manejo de errores que cualquier otra cosa.

No comprender completamente cómo funcionan los operadores (aritméticos, lógicos y otros).

Aquí hay un ejemplo simple. ¿Puede decir de inmediato qué mostrará este código?

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

Si respondió incorrectamente o simplemente adivinó, todavía tiene lagunas de conocimiento en esta área :)

El código mostrará false , porque el operador de igualdad ( == ) tiene mayor prioridad que el operador de incremento de sufijo ( ++ ). Por lo tanto, la comparación 7 == i se ejecuta primero, y solo entonces se realiza la operación i++ .

Por cierto, también tuvimos una lección detallada sobre esto. Aquí está el enlace si te lo perdiste.

Omitir la palabra break en una sentencia switch .

¡Muchas personas que leen este artículo ciertamente han cometido este error! :)

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

Como resultado, la ejecución pasa por todas las opciones posibles:

Producción:

El número es igual a 1 El número es igual a 2 El número es igual a 3

Una sentencia break interrumpe la ejecución de la sentencia switch cuando una de las opciones ha terminado de ejecutarse. No lo olvides o puedes obtener resultados inesperados :)