8 sai lầm thường gặp của người mới lập trình

Xin chào! Hôm nay chúng ta sẽ xem xét danh sách 8 lỗi phổ biến mà những nhà phát triển Java mới bắt đầu (và không chỉ) mắc phải. Bạn sẽ tìm thấy nhiều bộ sưu tập như vậy trên Internet: nhiều bộ sưu tập trong số đó tương tự nhau. Khi biên soạn danh sách này, chúng tôi đã được hướng dẫn bởi một tiêu chí: liệu bản thân chúng tôi có mắc phải những sai lầm này trong quá trình học tập và làm việc hay không :) Chúng không được ưu tiên và quan trọng như nhau đối với việc hiểu và ghi nhớ.

So sánh các đối tượng bằng cách sử dụng ==.

Toán tử ==so sánh các tham chiếu đối tượng.

Các tham chiếu trỏ đến các địa chỉ trong bộ nhớ và nếu chúng ở các địa chỉ khác nhau thì phép so sánh ==sẽ trả về false.
```
public class Car {

   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);
   }
}
```
Để so sánh các đối tượng trong một lớp, Objectcó một phương thức đặc biệt - equals(). Việc triển khai mặc định của nó, nói một cách thẳng thắn, là như vậy:
```
public boolean equals(Object obj) {
   return (this == obj);
}
```
Trong chính lớp đó, Objectlogic của phương thức equals()được triển khai dưới dạng so sánh hai tham chiếu. Đổi lại, để so sánh chính xác các đối tượng, bạn cần xác định lại phương pháp này theo các tiêu chí quan trọng trong một chương trình cụ thể cho các đối tượng cụ thể. Bạn tự xác định các tiêu chí cho sự bình đẳng.

Điều duy nhất bạn không nên quên là danh sách các yêu cầu để ghi đè thích hợp equals(). Bạn có thể dễ dàng tìm thấy chúng trên Internet, nhưng những sinh viên tuyệt vời của chúng tôi đã thực hiện một bài viết về chủ đề này .
Sử dụng các biến không tĩnh trong các phương thức tĩnh (và ngược lại).

Nếu bạn đã từng nhìn thấy dòng chữ “ Biến không tĩnh x không thể được tham chiếu từ ngữ cảnh tĩnh ” - chào mừng bạn đến với câu lạc bộ :)

Các phương thức tĩnh không có quyền truy cập vào các biến lớp không tĩnh.

Điều này là hợp lý: xét cho cùng, một phương thức tĩnh có thể được gọi mà không cần tạo đối tượng lớp và tất cả các biến trường đều thuộc về các đối tượng cụ thể. Đây chính là sự mâu thuẫn dẫn đến sai lầm.

Ngược lại, có thể: được phép sử dụng các biến tĩnh trong các phương thức không tĩnh:
```
public class Main {

   public int x = 10;

   public static int staticX = 100;

   public static void main(String[] args) {

       System.out.println(x);//ошибка компиляции, так нельзя!
   }

   public void printX() {

       System.out.println(staticX);//а так можно!
   }
}
```
Hiểu sai về cách truyền tham số cho phương thức: theo tham chiếu hoặc theo giá trị.

Các đối tượng và nguyên hàm được truyền cho các phương thức dưới dạng tham số theo nhiều cách khác nhau: đối tượng trước theo tham chiếu, đối tượng sau theo giá trị.

Những người mới bắt đầu thường thấy khái niệm này khó nắm bắt, dẫn đến mã của họ hoạt động không như mong muốn:
```
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++;
   }
}
```
Nếu trong ví dụ này, bạn không biết chính xác con số nào sẽ tăng và con số nào không (con số thông thường hoặc tuổi của con mèo), thì hãy đọc lại bài giảng của chúng tôi về chủ đề này một lần nữa .
Bỏ qua các quy tắc viết mã.

Và điều này không chỉ áp dụng cho việc tuân thủ các nguyên tắc “kỹ thuật” nhất định mà còn áp dụng cho các quy ước đặt tên tầm thường.

Tất cả những quy tắc “ cách đặt tên biến ”, “ cách viết tên phương thức ” được phát minh ra đều có lý do. Điều này thực sự ảnh hưởng lớn đến khả năng đọc mã.

Ведь code не всегда будет только твоим. Ты можешь перевестись на другой проект в компании, и он перейдет по наследству к твоим коллегам, которые будут явно не в восторге, получив в работу что-то вроде этого:
```
public class Cat {

   private int S_O_M_E_T_H_I_N_G = 7;
   public String striiiiiiiiiiiiiing;
   protected double X3_4TO_ET0_TAK0E = 3.14;
   boolean random = Math.random() > 0.5;

}
```
Твой code может быть гениальным с точки зрения производительности, но если его невозможно прочитать и понять How он, собственно, работает, цена его, увы, невелика.

Придерживайся стандартов написания, и твой code, даже далекий от идеала, хотя бы прочтут более опытные товарищи и подскажут, что с технической точки зрения в нем можно улучшить :)
Непонимание работы класса String
```
public class Main {

   public static void main(String[] args) {

       String s1 = "Я изучаю Java";
       String s2 = new String("Я изучаю Java");

       System.out.println(s1 == s2);
   }
}
```
Если ты не знаешь, почему этот code выводит false, знания явно нужно подтянуть:)

Новички часто не знают что такое String Pool и How он работает.

Как следствие, не до конца ясно, How правильно сравнивать строки в своем codeе. В одной из наших лекций мы подробно рассматривали эту тему
Неправильная работа с исключениями.

Это свойственно не только новичкам, но и опытным разработчикам. Причин несколько.

Во-первых, универсального рецепта не существует. Ошибки в программе бывают разные, сценарии их обработки, соответственно, тоже. Во-вторых, не все понимают структуру stackTrace, а антипаттернов обработки ошибок очень много, и каждый из них «неправилен» по-своему. Так что вариантов сделать неправильно здесь намного больше, чем где бы то ни было.

Распространенные антипаттерны приведены здесь:
- Антипаттерны обработки исключений в Java;
- Исправляем 7 распространенных ошибок обработки исключения в Java.
Неполное понимание работы операторов (арифметических, логических и других).

Простой пример. Сможешь сходу сказать, что выведет этот code?
```
public class Main {

   public static void main(String[] args) {

       int i = 6;
       System.out.println(7 == i++);
   }
}
```
Если ты ответил неправильно or наугад, значит, в этой области пока есть пробелы:)

Код выведет false, потому что приоритет у оператора сравнения == выше, чем у постфиксного инкремента ++. Поэтому сначала будет выполнено сравнение 7 == i, и только потом - операция i++.

По этой теме, кстати, у нас тоже была подробная лекция. Вот link, если пропустил.

Пропуск слова break в операторе switch.

Эту ошибку, вероятно, допускали многие из читателей!)

public class Main {

   public static void main(String[] args) {

       int i = 1;

       switch (i) {

           case 1: {
               System.out.println("Число равно 1");
           }
           case 2: {
               System.out.println("Число равно 2");
           }
           case 3: {
               System.out.println("Число равно 3");
           }
       }
   }
}

В результате на них обрушивается водопад из всех возможных вариантов:

Вывод:


Число равно 1
Число равно 2
Число равно 3

Оператор break прерывает работу оператора switch в момент, когда отработал один из вариантов. Не стоит о нем забывать, иначе результат может быть неожиданным :)