Przerwa kawowa #98. Nowy wyjątek Nullpointer w Javie 17. Co oznacza w Javie?

Nowy wyjątek Nullpointer w Javie 17

Źródło: Dev.to Każdy programista Java powinien wiedzieć o istnieniu nowego wyjątku Nullpointer , czyli NPE w Javie 17. Jest to jedna z takich sytuacji, której zawsze powinieneś starać się zapobiegać. Czasami Nullpointer oznacza, że ​​musisz debugować swój kod, aby znaleźć mały błąd. NPE to wyjątek czasu wykonania, który występuje, gdy kod chce użyć obiektu lub odwołania do obiektu, który ma wartość null. Może się to zdarzyć, jeśli nie przypisano żadnej wartości lub obiekt nie ma odniesienia. Przed najnowszą wersją OpenJDK (wersja 17) normalny wyjątek Nullpointer w śladzie stosu wyglądałby mniej więcej tak:

java.lang.NullPointerException: null

Oczywiście to nie wszystko, co musisz wiedzieć o śladach stosu. Jak widać, nie wskazuje, gdzie i dlaczego wystąpił ten wyjątek. Zobacz, jak Java 17 radzi sobie z tym problemem:

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

W tym przykładzie wyjątek wskazuje, gdzie i jakie jest nasze odwołanie do obiektu zerowego. To takie proste!

Co oznacza <T> w Javie?

Źródło: Dev.to <T> to popularna litera oznaczająca „Typ” i odnosząca się do koncepcji ogólnej w Javie. Możesz użyć do tego innej litery, ale jak widać, preferowana jest litera T.

Co to jest generyczny?

Generic to sposób parametryzacji klasy, metody lub interfejsu. Spójrzmy na przykład rodzaju ogólnego:

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

• Mamy klasę o nazwie House , która akceptuje dowolny typ obiektu.
• Następnie mamy pole o nazwie DoorNumber , które może również przyjąć dowolny typ obiektu.
• Na koniec deklarujemy sparametryzowanego konstruktora i drukujemy numer drzwi.

Mówiąc najprościej, użytkownik może zdecydować, czy ta liczba jest liczbą całkowitą, ciągiem znaków, zmiennoprzecinkową i tak dalej. UWAGA: możesz używać tylko Obiektów . Typy pierwotne nie są obsługiwane, ponieważ typy generyczne są przeznaczone do użycia w czasie kompilacji. Kiedy używamy Generics, T zastępuje wszystko, co może rozszerzyć klasę Object , a prymitywy nie mają tej właściwości. Powiedzmy, że chcemy, aby numer drzwi był ciągiem znaków.

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

    }
}

Wynik będzie wyglądał następująco: Zastąpimy literę „T” literą „String” i wpiszemy numer domu do konstruktora. Możemy użyć wielu typów, jeśli na przykład potrzebujemy klasy, aby zaakceptować więcej niż jeden obiekt. Możemy dodać kolejną literę i tym samym powiedzieć: chcemy, aby klasa zaakceptowała inną literę rodzajową.

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();

    }
}

Wynik będzie następujący: Do tej pory widzieliśmy przykłady użycia Generic na poziomie zajęć. Ale możemy też mieć wspólne metody i interfejsy.

Metoda ogólna

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

    }
}

Metoda akceptuje obiekt dowolnego typu i wyprowadza numer drzwi, którym będzie obiekt dowolnego typu . W tym przypadku chcemy, aby metoda akceptowała liczbę całkowitą. Rezultatem będzie:

Ogólny interfejs

Najpierw utwórz interfejs.

package Generics;

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

Następnie zaimplementuj interfejs.

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

}

Wynik: Jakie są zalety stosowania leków generycznych?

1. Lepsze sprawdzanie czasu kompilacji : jeśli użyjesz typu obiektu innego niż określony, kompilator poinformuje Cię o tym.
2. Ponowne użycie : możesz używać klasy, metody lub interfejsu wiele razy, ponieważ decydujesz, jakiego typu obiektu użyć w zależności od tego, co próbujesz osiągnąć.
3. Świetnie nadaje się do struktur danych i algorytmów : ArrayList i HashMap to tylko kilka przykładów użycia Generic.