8 karaniwang pagkakamali na ginawa ng mga baguhang programmer

Paghahambing ng mga bagay gamit ang == .

Ang == operator ay naghahambing ng mga sanggunian sa bagay.

Itinuturo ng mga sanggunian ang mga address sa memorya. Kung sila ay naka-imbak sa iba't ibang mga address, ang paghahambing gamit ang == ay magbabalik ng 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);
    }
}

Upang ihambing ang mga bagay, ang klase ng Bagay ay may espesyal na pamamaraan: equals() . Sa totoo lang, ang default na pagpapatupad nito ay hindi masama:

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

Sa mismong klase ng Object , ang equals() na pamamaraan ay ipinatupad bilang paghahambing ng dalawang sanggunian. Sa turn, upang maihambing nang tama ang mga bagay, kailangan mong muling tukuyin ang pamamaraang ito ayon sa pamantayan na nauugnay sa iyong partikular na programa para sa iyong mga partikular na bagay. Ang pamantayan para sa pagkakapantay-pantay ay nasa iyo.

Ang tanging bagay na hindi mo dapat kalimutan ay ang listahan ng mga kinakailangan para sa maayos na pag-override equals() . Madali mong mahahanap ang mga ito sa Internet.

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

Kung nakita mo na ang mensaheng "Hindi maaaring i-reference ang non-static na variable x mula sa isang static na konteksto", maligayang pagdating sa club :)

Ang mga static na pamamaraan ay walang access sa mga di-static na (halimbawa) na mga variable.

Makatuwiran ito: pagkatapos ng lahat, ang isang static na pamamaraan ay maaaring tawagin nang hindi lumilikha ng isang bagay ng klase nito, at lahat ng mga patlang ay nabibilang sa mga partikular na bagay. At dito nakasalalay ang kontradiksyon na nagdudulot ng pagkakamali.

Sa pamamagitan ng paraan, ang pagpunta sa ibang paraan ay gumagana nang maayos: maaari kang 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); // Compilation error - you can't do this!
    }
 
    public void printX() {
 
        System.out.println(staticX); // But you can do this!
    }
}

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

Ang mga bagay at primitive ay ipinapasa sa mga pamamaraan sa dalawang magkaibang paraan: una, sa pamamagitan ng sanggunian; pangalawa, ayon sa halaga.

Ang mga nagsisimula ay madalas na nahihirapang maunawaan ang konseptong ito. Bilang resulta, ang kanilang code ay 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 hindi mo alam kung aling numero ang tataas at alin ang hindi (ang simpleng lumang numero o edad ng pusa), pagkatapos ay basahin muli ang aming aralin sa paksa .

Hindi pinapansin ang mga panuntunan sa coding.

Nalalapat ito hindi lamang sa pagsunod sa ilang partikular na "teknikal" na mga prinsipyo, kundi pati na rin sa mga makamundong 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. Talagang nakakaapekto ang mga ito sa pagiging madaling mabasa ng code

Pagkatapos ng lahat, ang code ay hindi palaging magiging sa iyo nag-iisa. Maaari kang ilipat sa ibang proyekto sa iyong kumpanya. Ang iyong mga katrabaho na nagmamana ng iyong code ay halatang hindi matutuwa kapag nakakita sila ng ganito:

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

Ang iyong code ay maaaring magkaroon ng napakahusay na pagganap, ngunit kung imposibleng basahin at maunawaan kung paano ito aktwal na gumagana, kung gayon, sayang, hindi ito nagkakahalaga ng malaki.

Kung mananatili ka sa mga pamantayan sa coding, kung gayon kahit na ang iyong code ay malayo sa perpekto, hindi bababa sa iyong mas may karanasan na mga katrabaho ang makapagsasabi sa iyo kung paano ito mapapahusay mula sa teknikal na pananaw :)

Hindi pagkakaunawaan sa klase ng 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);
    }
}

Kung hindi mo alam kung bakit mali ang ipinapakita ng code na ito , malinaw na kailangan mong dagdagan ang iyong kaalaman :)

Ang mga nagsisimula ay madalas na walang kamalayan sa String Pool at kung paano ito gumagana.

Bilang resulta, hindi nila lubos na nauunawaan kung paano maayos na ihambing ang mga string sa kanilang code. Sinaliksik namin ang paksang ito nang detalyado sa isa sa aming mga aralin .

Hindi tama ang paghawak ng mga exception.

Ang mga nagsisimula ay hindi lamang ang natitisod dito. Nababadtrip din ang mga may karanasang developer. Ang mga dahilan ay marami.

Una, walang unibersal na recipe. Ang mga programa ay may lahat ng uri ng iba't ibang mga error at iba't ibang mga sitwasyon sa paghawak ng error.

Pangalawa, hindi lahat ay nauunawaan kung paano nakaayos ang isang stack trace . Maraming error sa paghawak ng mga antipattern, at ang bawat isa sa kanila ay "mali" sa sarili nitong paraan. Nangangahulugan ito na mas madaling magkaroon ng mali sa paghawak ng error kaysa sa anumang bagay.

Hindi lubos na nauunawaan kung paano gumagana ang mga operator (aritmetika, lohikal at iba pa).

Narito ang isang simpleng halimbawa. Masasabi mo ba kaagad kung ano ang ipapakita ng code na ito?

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

Kung mali ang sagot mo o nahulaan mo lang, may mga gaps ka pa rin sa kaalaman sa lugar na ito :)

Ang code ay magpapakita ng false , dahil ang equality operator ( == ) ay may mas mataas na priyoridad kaysa sa postfix increment operator ( ++ ). Samakatuwid, ang paghahambing na 7 == i ay ibinukod muna, at pagkatapos lamang ay isinagawa ang i++ na operasyon.

Sa pamamagitan ng paraan, mayroon din kaming isang detalyadong aralin tungkol dito. Narito ang link kung napalampas mo ito.

Pag-alis ng salitang break sa isang switch statement.

Maraming mga tao ang nagbabasa ng artikulong ito ay tiyak na nakagawa ng pagkakamaling ito! :)

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

Bilang resulta, ang pagpapatupad ay bumabagsak sa bawat posibleng opsyon:

Output:

Ang numero ay katumbas ng 1 Ang numero ay katumbas ng 2 Ang numero ay katumbas ng 3

Ang isang break na pahayag ay nakakaabala sa pagpapatupad ng switch statement kapag ang isa sa mga opsyon ay tapos nang isagawa. Huwag kalimutan ito o maaari kang makakuha ng hindi inaasahang resulta :)