Mga sikat na pagkakamali na ginawa ng mga baguhang programmer

"Hi, Amigo! Let's continue to talk about mistakes. This time, we'll explore mistakes that the compiler will not always help you with. Mag-ingat at may matutunan ka tungkol sa iyong sarili."

"Handa akong makinig, Diego. Sana hindi ito masyadong nakakahiya para sa akin."

Paghahambing ng mga bagay sa==

"Ang aming listahan ng mga nangungunang paboritong pagkakamali ng newbie programmer ay nagsisimula sa paghahambing ng mga bagay (lalo na ang mga string) gamit ang ==operator"

Halimbawa:

Scanner console = new Scanner(System.in);
String s1 = console.nextLine();
String s2 = console.nextLine();
if (s1 == s2)
{
   System.out.println("The strings are equal");
}

"Madalas kong ginawa iyon. Ngayon ay malinaw kong nakikita na ang code na ito ay hindi kailanman magpapakita ng "The strings are equal", dahil ifinihahambing ng statement ang mga reference sa dalawang magkaibang string object."

"Oo. Kaya ang tamang opsyon ay:

Scanner console = new Scanner(System.in);
String s1 = console.nextLine();
String s2 = console.nextLine();
if (s1.equals(s2))
{
   System.out.println("The strings are equal");
}

Pagbabago ng isang Stringbagay

"Madalas nakakalimutan ng mga newbie programmer na ang lahat ng object ng klase ay hindi nababago , at ang bawat paraan ng Stringklase ay nagbabalik ng bagong object — hindi nagbabago ang kasalukuyang object."

"Hindi pa ganoon katagal natutunan ko kung ano ang ibig sabihin ng immutable , ngunit sa palagay ko nagawa ko na ito.

"Medyo sigurado ako dito. Halimbawa:

String s = "Hello";
s.toUpperCase (); // Convert to uppercase

"Ang code na ito ay halos kapareho sa tamang code, ngunit hindi ito gagana gaya ng inaasahan. Hindi toUpperCase()binabago ng pamamaraan ang object kung saan ito tinawag. Ang tamang code ay magiging ganito:

String s = "Hello";
String result = s.toUpperCase(); // Convert to uppercase

"Eksakto. Nagawa ko na, pero hindi ko man lang naintindihan kung ano ang mali. Salamat sa paglilinaw!"

Nakakalimutang simulan ang mga bagay na elemento ng isang array

"Ang isa pang karaniwang pagkakamali ay ang kalimutang simulan ang isang array variable. Halimbawa:

int[] array;
array[0] = 1;
array[0] = 2;

"Hindi gagana ang code na ito: kailangan mong tahasang itakda ang array variable na katumbas ng isang reference sa container object na mag-iimbak ng mga elemento ng array. Tamang bersyon:

int[] array = new int[10];
array[0] = 1;
array[0] = 2;

Paggamit ng isang lokal na variable sa halip na isang instance variable.

"Ang mga baguhan ay hindi gustong makabuo ng mahaba at makabuluhang mga pangalan para sa mga variable."

"Napakatotoo niyan. Para mabilis magawa ang mga bagay-bagay, minsan ay nagbibigay ako ng mga variable na pangalan tulad ng a, b, at i."

"Huwag gawin iyan. Iyan ay isang malupit na bagay na dapat gawin kapag ang code ay may ilang mga variable na tulad niyan:

class Solution
{
  public static int a = 99;
  public static int i = 100;

  public static void main(String[] args)
  {
    int[] a = new int[i];
    for (int i = 0; i < 10; i++)
    {
      a[i] = a;
    }
  }
}

"Mas mahirap na magkamali sa code na may wastong mga pangalan. Ang tamang bersyon ay ganito:

class Solution
{
   public static int value = 99;
   public static int count = 100;

   public static void main(String[] args)
   {
      int[] a = new int[count];
      for (int i = 0; i < 10; i++)
      {
         a[i] = value;
      }
   }
}

Pag-alis ng item sa koleksyon

"Nakatingin ka na ba sa mga koleksyon?"

"Literally sa isang mata lang."

"Kung hindi mo alam kung ano ang pinag-uusapan ko, pagkatapos ay gumawa ng isang tala sa iyong sarili upang tingnan sa hinaharap. Kadalasan mayroong mga sitwasyon kapag ang isang partikular na elemento ay kailangang alisin mula sa isang koleksyon. Ang code ay halos katulad ng ito:

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);

for (Integer value: list)
   if (value < 0)
      list.remove(value);

"Hindi gagana ang code na ito, dahil hindi ka maaaring gumamit ng for-eachloop upang sabay-sabay na daanan ang mga elemento ng isang koleksyon at baguhin ang koleksyong iyon.

"Mayroong ilang mga solusyon. Una, maaari kang dumaan sa isang koleksyon at baguhin ang isa pa:

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);

ArrayList<Integer> copy = new ArrayList<Integer>(list);
for (Integer value: copy)
   if (value < 0)
      list.remove(value);

"Pangalawa, mula noong Java 8, ang mga koleksyon ay may removeIf()pamamaraan, kung saan maaari kang magpasa ng isang panuntunan (lambda function) na nagsasaad kung aling mga elemento ang aalisin. Halimbawa:

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);

list.removeIf( x-> x<0 );

Paglalagay ng ilang mga klase na may publicmodifier sa isang file

"Maaaring magkaroon lamang ng isang pampublikong klase sa isang file. Higit pang mga klase ang maaaring ideklara sa isang file, ngunit dapat silang mga panloob na klase ng isang pampublikong klase, o walang modifier. publicHalimbawa:

public class Solution
{
}
public class Main
{
}

public class Solution
{
}
class Main
{
}

public class Solution
{
  public static class Main
  {
  }
}

Ang pagtawag sa mga ordinaryong (non-static) na pamamaraan ng isang klase mula sa static main()na pamamaraan

"Minsan sinusubukan ng mga newbie programmer na i-access ang mga non-static na variable at pamamaraan mula sa main()pamamaraan o iba pang mga static na pamamaraan. Siyempre, hindi gagana ang naturang code.

public class Solution
{
   public int n = 100;
   public int[] createArray()
   {
      return new int[n];
   }

   public static void main(String[]args)
   {
      int[] array = createArray();
   }
}

"Ang mainpamamaraan ay maaari lamang sumangguni sa mga static na pamamaraan/mga variable. Well, o dapat muna itong lumikha ng isang instance ng Solutionklase, at pagkatapos ay tumawag lamang ng mga non-static na pamamaraan ng bagay na iyon. Halimbawa:

public class Solution
{
  public static int n = 100;

  public static int[] createArray()
  {
    return new int[n];
  }

  public static void main(String[]args)
  {
    int[] array = createArray();
  }
}

public class Solution
{
  public int n = 100;

  public int[] createArray()
  {
    return new int[n];
  }

  public static void main(String[]args)
  {
    Solution sol = new Solution();
    int[] array = sol.createArray();
  }
}

Ang pagdedeklara ng isang constructor tulad ng isang pamamaraan

"Ang isa pang karaniwang pagkakamali ay ang maling pagdedeklara ng class constructor. Ang pangalan ng isang constructor ay dapat pareho sa pangalan ng class, at ang isang constructor ay walang uri ng resulta. Ang pinakakaraniwang pagkakamali ay ganito ang hitsura:

public class Person
{
   private String value;

   void Person(String value)
   {
      this.value = value;
   }
}

public class Person
{
   private String value;

   constructor(String value)
   {
      this.value = value;
   }
}

public class Person
{
   private String value;

   Person(String value)
   {
      value = value;
   }
}

public class Person
{
   private String value;

   Person(String value)
   {
      this.value = value;
   }
}

Maling inheritance ng mga interface

"Sinubukan ng mga tagalikha ng Java na gawin itong napakalapit sa Ingles, kaya pumili sila ng iba't ibang mga keyword para sa ilang partikular na nauugnay na konsepto.

Kapag ang isang klase ay nagmana ng isang klase, kailangan mong gamitin ang extendskeyword:

class Pet
{
}

class Cat extends Pet
{
}

"Kapag ang isang klase ay nagmana ng isang interface, o, mas tiyak, ipinatupad ito, kailangan mong gamitin ang implementskeyword:

interface Meow
{
}

class Cat implements Meow
{
}

"Kapag ang isang interface ay nagmana ng isang interface, gamitin ang extendskeyword:

interface Meow
{
}

interface Voice extends Meov
{
}

Pag-alis breaksa isang switchpahayag

"At ang huling pagkakamali para sa araw na ito, ngunit hindi ang huli para sa mga nagsisimula, ay ang hindi pagsasama ng isang breakpahayag sa isang switchpahayag. Halimbawa:

LocalDate date = LocalDate.now();
DayOfWeek day = date.getDayOfWeek();
switch (day)
{
   case MONDAY:
      System.out.println("Monday");
   case TUESDAY:
      System.out.println("Tuesday");
   case WEDNESDAY:
      System.out.println("Wednesday");
   case THURSDAY:
      System.out.println("Thursday");
   case FRIDAY:
      System.out.println("Friday");
   case SATURDAY:
      System.out.println("Saturday");
   case SUNDAY:
      System.out.println("Sunday");
}

LocalDate date = LocalDate.now();
DayOfWeek day = date.getDayOfWeek();
switch (day)
{
   case MONDAY:
      System.out.println("Monday");
      break;
   case TUESDAY:
      System.out.println("Tuesday");
      break;
   case WEDNESDAY:
      System.out.println("Wednesday");
      break;
   case THURSDAY:
      System.out.println("Thursday");
      break;
   case FRIDAY:
      System.out.println("Friday");
      break;
   case SATURDAY:
      System.out.println("Saturday");
      break;
   case SUNDAY:
      System.out.println("Sunday");
      break;
}

"Alam mo, Diego... Base sa set of errors na ipinakita mo dito, parang binabasa mo ang personal journal ko... O pinapanood mo akong mag-solve ng mga gawain."

"Ha! Huwag kang mag-alinlangan tungkol dito. Nabasa ko, nasubaybayan, at patuloy na ginagawa ito. Kaya't maging alerto!"

"???"

"Don't you worry. Nagbibiro lang ako. Be vigilant and make few stupid mistakes."