Coffee break #98. Bagong Nullpointer exception sa Java 17. Ano ang ibig sabihin ng sa Java?

Bagong Nullpointer exception sa Java 17

Source: Dev.to Dapat malaman ng bawat developer ng Java ang tungkol sa pagkakaroon ng bagong Nullpointer Exception o NPE sa Java 17. Isa itong sitwasyon na dapat mong laging subukang pigilan. Minsan ang Nullpointer ay nangangahulugan na kailangan mong i-debug ang iyong code upang makahanap ng maliit na bug. Ang NPE ay isang runtime exception na nangyayari kapag ang iyong code ay gustong gumamit ng object o isang reference sa isang object na may null value. Ito ay maaaring mangyari kung walang halaga ang itinalaga o ang bagay ay walang reference. Bago ang pinakabagong bersyon ng OpenJDK (bersyon 17), ang isang normal na Nullpointer exception sa stack trace ay magiging ganito ang hitsura:

java.lang.NullPointerException: null

Siyempre, hindi lang iyon ang kailangan mong malaman tungkol sa mga stack traces. Gaya ng nakikita mo, hindi nito ipinapahiwatig kung saan o bakit nangyari ang pagbubukod na ito. Tingnan kung paano tinatalakay ng Java 17 ang problemang ito:

Exception in thread "main" java.lang.NullPointerException:
Cannot assign field "i" because "a" is null
at Prog.main(Prog.java:5)

Sa halimbawang ito, ang pagbubukod ay nagpapahiwatig kung saan at kung ano ang aming null object reference. Ganun kasimple!

Ano ang ibig sabihin ng <T> sa Java?

Source: Dev.to <T> ay isang karaniwang titik na nangangahulugang "Uri" at ito ay tumutukoy sa Generic na konsepto sa Java. Maaari kang gumamit ng isa pang titik para dito, ngunit tulad ng nakikita mo, ang titik T ay mas kanais-nais.

Ano ang Generic?

Ang generic ay isang paraan para i-parameter ang isang klase, pamamaraan, o interface. Tingnan natin ang isang halimbawa ng generic:

package Generics;

class House<T>{

    T doorNumber;

    public House(T doorNumber) {
        this.doorNumber = doorNumber;
    }

    public void print(){
        System.out.println("Your house number is: " + this.doorNumber);
    }
}

• Mayroon kaming klase na tinatawag na House na maaaring tumanggap ng arbitrary na uri ng bagay.
• Susunod na mayroon kaming isang patlang na tinatawag na doorNumber , na maaari ring tumanggap ng anumang uri ng bagay.
• Sa dulo, ipinapahayag namin ang isang parameterized constructor at i-print ang numero ng pinto.

Sa madaling salita, maaaring magpasya ang user kung ang numerong ito ay Integer, String, Float, at iba pa. TANDAAN: maaari mo lamang gamitin ang Objects . Hindi sinusuportahan ang mga primitive na uri dahil nilalayong gamitin ang mga generic sa oras ng pag-compile. Kapag gumagamit kami ng Generics, pinapalitan ng T ang anumang bagay na maaaring mag-extend ng Object class , at ang mga primitive ay walang ganitong property. Sabihin nating gusto nating maging string ang doorNumber .

public class GenericsExample {
    public static void main(String[] args) {
        House<String> mainHouse = new House<>("14a");
        mainHouse.print();

    }
}

Magiging ganito ang resulta: Papalitan namin ang letrang "T" ng "String" at ipasok ang numero ng bahay sa constructor. Maaari kaming gumamit ng maraming uri kung, halimbawa, kailangan namin ng isang klase upang tumanggap ng higit sa isang bagay. Maaari kaming magdagdag ng isa pang liham at sa gayon ay masasabing: gusto naming tanggapin ng klase ang isa pang Generic.

package Generics;

class House<T, V>{

    T doorNumber;
    V streetName;

    public House(T doorNumber, V streetName) {
        this.doorNumber = doorNumber;
        this.streetName = streetName;
    }

    public void print(){
        System.out.println("You live at: " + this.doorNumber + " " + this.streetName);
    }
}

public class GenericsExample {
    public static void main(String[] args) {
        House<Integer, String> mainHouse = new House<>(14, "Tellson Avenue");
        mainHouse.print();

    }
}

Ang resulta ay magiging ganito: Sa ngayon ay nakakita kami ng mga halimbawa ng paggamit ng Generic sa antas ng klase. Ngunit maaari rin tayong magkaroon ng mga karaniwang pamamaraan at interface.

Pangkalahatang pamamaraan

package Generics;

class House{

    public <T> void print(T doorNumber){
        System.out.println("You live at house number: " + doorNumber);
    }

}

public class GenericsExample {
    public static void main(String[] args) {
        House mainHouse = new House();
        mainHouse.<Integer>print(14);

    }
}

Ang pamamaraan ay tumatanggap ng anumang uri ng bagay at naglalabas ng numero ng pinto, na magiging anumang uri ng Bagay . Sa kasong ito, gusto namin ang pamamaraan na tumanggap ng isang integer. Ang magiging resulta ay:

Pangkalahatang interface

Lumikha muna ng interface.

package Generics;

interface Property<T>{
    void hasBalcony(T balcony);
}

Pagkatapos ay ipatupad ang interface.

package Generics;

public class House implements Property<String> {

    @Override
    public void hasBalcony(String balcony) {
        System.out.println("Is there a balcony in the room? " + balcony);
    }

    public static void main(String[] args) {
        House mainHouse = new House();
        mainHouse.hasBalcony("YES");
    }

}

Resulta: Ano ang mga pakinabang ng paggamit ng generics?

1. Mas mahusay na pagsusuri sa oras ng pag-compile : Kung gumamit ka ng uri ng bagay maliban sa tinukoy mo, sasabihin ito sa iyo ng compiler.
2. Reusability : Maaari kang gumamit ng klase, pamamaraan, o interface nang maraming beses dahil magpapasya ka kung aling uri ng object ang gagamitin depende sa kung ano ang sinusubukan mong makamit.
3. Ito ay mahusay para sa mga istruktura at algorithm ng data : Ang ArrayList at HashMap ay ilan lamang sa mga halimbawa kung saan ginagamit ang Generic.