8 karaniwang pagkakamali ng mga baguhang programmer

Paghahambing ng mga bagay gamit ang ==.

Inihahambing ng operator ==ang mga sanggunian sa bagay.

Ang mga sanggunian ay tumuturo sa mga address na nasa memorya, at kung sila ay nasa magkaibang mga address, ang paghahambing sa pamamagitan ==ay babalik 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);
   }
}

Upang ihambing ang mga bagay sa isang klase Objectmayroong isang espesyal na pamamaraan - equals(). Ang default na pagpapatupad nito, sa totoo lang, ay ganito:

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

Sa klase mismo, Objectang lohika ng pamamaraan equals()ay ipinatupad bilang paghahambing ng dalawang sanggunian. Sa turn, upang maihambing nang tama ang mga bagay, kailangan mong muling tukuyin ang pamamaraang ito alinsunod sa mga pamantayan na mahalaga sa isang partikular na programa para sa mga partikular na bagay. Ikaw mismo ang magdedetermina ng pamantayan para sa pagkakapantay-pantay.

Ang tanging bagay na hindi mo dapat kalimutan ay ang listahan ng mga kinakailangan para sa tamang pag-override equals(). Madali mong mahahanap ang mga ito sa Internet, ngunit ang aming mga cool na mag-aaral ay nakagawa na ng artikulo sa paksang ito .

Paggamit ng mga non-static na variable sa mga static na pamamaraan (at vice versa).

Kung nakita mo na ang inskripsyon na " Ang hindi static na variable x ay hindi maaaring i-reference mula sa isang static na konteksto " - maligayang pagdating sa club :)

Ang mga static na pamamaraan ay walang access sa mga di-static na variable ng klase.

Ito ay lohikal: pagkatapos ng lahat, ang isang static na pamamaraan ay maaaring tawagin nang hindi lumilikha ng isang object ng klase, at lahat ng mga variable ng field ay nabibilang sa mga partikular na bagay. Ito ang kontradiksyon na humahantong sa pagkakamali.

Sa kabaligtaran, sa pamamagitan ng paraan, posible: pinapayagan na gumamit ng mga static na variable sa mga non-static na pamamaraan:

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);//а так можно!
   }
}

Hindi pagkakaunawaan kung paano ipinapasa ang mga parameter sa mga pamamaraan: sa pamamagitan ng sanggunian o sa pamamagitan ng halaga.

Ang mga bagay at primitive ay ipinapasa sa mga pamamaraan bilang mga parameter sa iba't ibang paraan: ang una sa pamamagitan ng sanggunian, ang huli sa pamamagitan ng halaga.

Ang mga nagsisimula ay madalas na mahirap maunawaan ang konseptong ito, na nagreresulta sa kanilang code na kumikilos nang hindi inaasahan:

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

Kung sa halimbawang ito ay hindi mo alam kung aling numero ang tataas at alin ang hindi (ang karaniwang numero o edad ng pusa), pagkatapos ay muling basahin ang aming lecture sa paksang ito muli .

Hindi pinapansin ang mga alituntunin sa pagsulat ng code.

At nalalapat ito hindi lamang sa pagsunod sa ilang mga "teknikal" na mga prinsipyo, kundi pati na rin sa mga banal na kombensiyon sa pagbibigay ng pangalan.

Ang lahat ng mga panuntunang ito " kung paano pangalanan ang mga variable ", " kung paano magsulat ng mga pangalan ng pamamaraan " ay naimbento para sa isang dahilan. Ito ay talagang lubos na nakakaapekto sa pagiging madaling mabasa ng code.

Ведь 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 в момент, когда отработал один из вариантов. Не стоит о нем забывать, иначе результат может быть неожиданным :)