Referencje – pojęcie i zastosowanie

Wszystkie obiekty w języku Java są obsługiwane przez referencje. Nie należy ich jednak mylić ze wskaźnikami lub referencjami języka C++. Różnica polega na tym, że referencje w języku Java nie odnoszą się bezpośrednio do lokalizacji pamięci, ale zawierają wskaźnik do rzeczywistej lokalizacji pamięci, do której programista nie może uzyskać bezpośredniego dostępu. Ten dodatkowy poziom pośrednictwa jest wymagany m.in. do działania Garbage CollectoraGarbage Collector (GC)Garbage Collectora.

Przyjrzymy się definicji klasy o nazwie Osoba, która zawiera pole imie typu String służące do przechowywania imienia osoby. W głównej metodzie programu tworzony jest nowy obiekt klasy Osoba o nazwie znajomy, a do pola imie tego obiektu przypisywane jest imię „Artur”. Poprzez wykonanie tego kodu, tworzony jest obiekt reprezentujący osobę o imieniu „Artur”, co demonstruje podstawowe zastosowanie klas i obiektów w programowaniu obiektowym w języku Java.

// Definicja klasy Osoba
class Osoba {
    // Pole imie typu String przechowujące imię osoby
    String imie;

    // Główna metoda programu
    public static void main(String[] args) {
        // Utworzenie nowego obiektu klasy Osoba
        Osoba znajomy = new Osoba();

        // Przypisanie wartości do pola imie obiektu znajomy
        znajomy.imie = "Artur";
    }
}

Zwróć uwagę na słowo kluczowe new.

Słowo kluczowe new w języku Java służy do tworzenia nowych obiektów. Gdy go używamy, rezerwujemy pamięć na nowy obiekt na stercie (z j. ang. heap) i inicjalizujemy go zgodnie z definicją jego klasy. Ogólna składnia new wygląda następująco:

TypObiektu nazwaObiektu = new TypObiektu();

gdzie:

• TypObiektu to nazwa klasy obiektu, który chcemy utworzyć;

• nazwaObiektu to nazwa zmiennej, która będzie przechowywać referencję do nowo utworzonego obiektu.

Kiedy słowo kluczowe new tworzy obiekt klasy Osoba, jest on przechowywany w obszarze pamięci zwanym stertąstertastertą. Referencja znajomy odwołuje się do nowo utworzonego obiektu. Należy również podkreślić, że zmienna znajomy tak naprawdę nie jest obiektem. Przechowuje jedynie informację, gdzie obiekt znajduje się w pamięci.

Możemy przypisywać referencje wielu zmiennym, które jeszcze nie odwołują się do żadnego obiektu. Technika ta jest szczególnie ważna przy implementacji struktur, takich jak drzewa binarne, listy, czy dowolne struktury z dowiązaniami.

Zaprezentujemy kod, który przedstawia klasę o nazwie Osoba, która zawiera pole imie typu String służące do przechowywania imienia osoby. Następnie w głównej metodzie programu utworzymy obiekt klasy Osoba o nazwie znajomy, a do jego pola imie przypiszemy imię „Jan”. W kodzie wykorzystamy również mechanizm referencji poprzez deklarację zmiennej brat typu Osoba, która początkowo jest inicjalizowana jako null, a następnie przypisywana jest do niej referencja do obiektu znajomy.

Kiedy zmienne brat i znajomy wskazują na ten sam obiekt, zmiany dokonane na jednej zmiennej (np. zmiana imienia za pomocą brat.imie = "Artur") będą miały wpływ na obie zmienne, ponieważ obie wskazują na ten sam obiekt. Oznacza to, że zarówno znajomy.imie jak i brat.imie będą teraz równoważne z „Artur”, ponieważ zmieniliśmy imię na obiekcie wskazywanym przez obie zmienne.

// Definicja publicznej klasy Osoba
public class Osoba {
    // Pole imie typu String przechowujące imię osoby
    String imie;
    
    // Główna metoda programu
    public static void main(String[] args) {
        // Utworzenie nowego obiektu klasy Osoba
        Osoba znajomy = new Osoba();
        // Przypisanie wartości do pola imie obiektu znajomy
        znajomy.imie = "Jan";
        // Wyświetlenie imienia znajomy
        System.out.println(znajomy.imie); // 'Jan'
        
        // Deklaracja zmiennej brat typu Osoba i inicjalizacja jej jako null
        Osoba brat = null;
        // Przypisanie obiektu znajomy do zmiennej brat
        brat = znajomy;
        // Wyświetlenie pola imie dla zmiennej brat (które jest takie samo jak znajomy)
        System.out.println(brat.imie); // 'Jan'
        // Zmiana imienia w obiekcie wskazywanym przez brat
        brat.imie = "Artur";
        // Ponieważ zmienne brat i znajomy wskazują na ten sam obiekt, zmiana imienia wpływa na oba
        System.out.println(znajomy.imie); // 'Artur'
    }
}

Wynik działania programu:

Jan // Program wyświetli 'Jan',
    // ponieważ to jest wartość przypisana
    // do pola imie obiektu znajomy.
Jan // Program wyświetli 'Jan',
    // ponieważ brat wskazuje na ten sam obiekt,
    // co znajomy.
Artur // Program wyświetli 'Artur'.
    // Mimo że zmiana została dokonana poprzez zmienną brat,
    // zmienna znajomy również rejestruje tę zmianę,
    // ponieważ obie zmienne odnoszą się do tego samego
    // obiektu w pamięci.

Język Java zawsze przekazuje parametry przez wartość. Choć dla typów prymitywnychzmienna typu prymitywnegotypów prymitywnych jest to dość oczywiste, to jednak dla obiektów charakterystyka ta może budzić wątpliwości. Przeanalizujmy następujący przykład, w którym za pomocą metody zmieniamy stan obiektu.

public class Osoba {
    // Deklaracja zmiennej instancji imie, która będzie przechowywać imię osoby
    String imie;

    // Metoda statyczna zmienImie, która przyjmuje obiekt klasy Osoba
    // i zmienia jego pole imie na 'Ania'
    static void zmienImie(Osoba osoba) {
        osoba.imie = "Ania";
    }

    // Główna metoda klasy
    public static void main(String[] args) {
        // Tworzenie nowego obiektu klasy Osoba
        Osoba znajoma = new Osoba();

        // Przypisanie wartości 'Ola' do pola imie obiektu znajoma
        znajoma.imie = "Ola";
        // Wyświetlenie wartości pola imie obiektu znajoma
        System.out.println(znajoma.imie); // 'Ola'

        // Wywołanie metody zmienImie dla obiektu znajoma
        zmienImie(znajoma);
        // Ponowne wyświetlenie wartości pola imie obiektu znajoma, po zmianie
        System.out.println(znajoma.imie); // 'Ania'
    }
}

Wynik działania programu:

Ola // Wypisuje 'Ola', ponieważ to jest 
    // aktualna wartość pola imie obiektu znajoma.
Ania // Wypisuje 'Ania', ponieważ metoda
    // zmienImie zmieniła wartość pola imie obiektu znajoma.

Po wywołaniu funkcji zmienImie() to nie wartość obiektu, lecz referencja znajoma jest kopiowana. Błędne jest twierdzenie, że obiekty w języku Java przekazywane są przez referencje. Język Java przekazuje każdy parametr przez wartość niezależnie od jego typu.

Dynamiczna alokacja pamięci

Maszyna wirtualna Javy przy uruchomieniu programu rezerwuje miejsce w pamięci RAM, które jest przeznaczone dla różnych komponentów maszyny. Wyjaśnimy działanie jedynie dwóch głównych sektorów wirtualnej pamięci Java, czyli stertystertasterty i stosustosstosu wątków.

Stos w wirtualnej maszynie Java to sekcja pamięci, która zawiera metody, zmienne lokalne i zmienne referencyjne. Dostęp do zawartości stosu jest zawsze wykonywany w kolejności LIFOLIFO (ang. Last In, First Out)LIFO. Gdy wywoływana jest funkcja, na szczycie stosu rezerwowany jest blok zawierający zmienne lokalne i referencje. Kiedy funkcja zakończy działanie blok odpowiadający funkcji zostaje zdjęty ze stosu, a wszystkie zmienne niezbędne do działania funkcji zostają usunięte.

Sterta to pamięć zarezerwowana na potrzeby alokacji dynamicznej. W przeciwieństwie do stosu nie ma wzorca określającego kolejność przydziału i zwalniania bloków. Można przydzielić blok w dowolnym momencie i w dowolnym czasie go zwolnić. Sterta służy do przechowywania typów obiektowych.

Zmienne referencyjne przechowują informację, gdzie obiekt, do którego się odwołują, przechowywany jest na stercie.

Garbage collector jest komponentem wirtualnej maszyny Java, który odpowiada za czyszczenie sterty. Śledzi obiekty w stercie i sprawdza, ile referencji odwołuje się do każdego z nich. Jeśli komponent zauważy obiekt, do którego nie odwołuje się żadna referencja, zwalnia obiekt ze sterty.

Tablice dynamiczne

W języku Java klasyczne tablice mają stałą wielkość. Oznacza to, że po tym jak nadamy im określony rozmiar, nie można ich rozszerzać ani zmniejszać. Aby zmienić rozmiar, trzeba utworzyć nową tablicę i skopiować dotychczasowe elementy. Operacja taka jest wysoce nieefektywna i uciążliwa.

Na szczęście istnieje już zdefiniowana kolekcja, która dostosowuje swój rozmiar, kiedy tylko zajdzie taka potrzeba. Kolekcja ta nazywa się ArrayList (znana także jako lista tablicowa) i jest jedną z klas Java Collection Framework. Listy tablicowe są również nazywane tablicami dynamicznymi, ponieważ ich rozmiar może się zmieniać w trakcie działania programu.

By skorzystać z tejże kolekcji, zaimportujemy zarówno klasę java.util.ArrayList, jak i interfejs java.util.List. Obiekt tej kolekcji deklarujemy następująco:

// Importowanie klasy ArrayList z pakietu java.util
import java.util.ArrayList;
// Importowanie interfejsu List z pakietu java.util
import java.util.List;

// Deklaracja klasy publicznej TabliceDynamiczne
public class TabliceDynamiczne {
    // Główna metoda programu
    public static void main(String[] args) {
        // Deklaracja zmiennej listaTablicowa typu interfejsu List, która przechowuje obiekty typu Integer
        // Inicjalizacja zmiennej listaTablicowa jako nowy obiekt ArrayList
        // ArrayList to klasa implementująca interfejs List, która używa tablicy do przechowywania elementów
        List<Integer> listaTablicowa = new ArrayList<>();
    }
}

Lista tablicowa jest klasą generycznątyp generycznyklasą generyczną z parametrem określonego typu, dlatego należy określić wewnątrz nawiasów ostrych typ przechowywanych wyrazów. Jedynym ograniczeniem jest to, że wyrazy muszą być obiektem. Dla typów prymitywnych należy wpisać ich obiektowy odpowiednik. Na przykład, jeśli lista tablicowa ma składać się z liczb całkowitych, musimy wpisać Integer tam, gdzie określamy typ przechowywanych elementów.

Sama lista tablicowa w tym momencie jest pusta, ale możemy modyfikować zawartość kolekcji niektórymi z metod opisanych w tabeli.

Metodę remove najlepiej stosować tylko dla elementów znajdujących się na końcu kolekcji. Wtedy nie tracimy zbyt dużo na szybkości działania, ponieważ złożoność czasowa takiej operacji wynosi $O(1)$. W sytuacjach, które wymagają usuwania elementów niekoniecznie znajdujących się na końcu, stosujemy inną kolekcję, np. LinkedList.

Lista tablicowa jest stosowana w każdej sytuacji, gdy priorytetem jest szybki dostęp do elementów kolekcji, które usuwać będziemy tylko w ostateczności.

Na pewno spotkamy się z sytuacją, w której potrzeba będzie iterować po każdym elemencie listy tablicowej. Sposobów iteracji jest wiele, my skupimy się na dwóch najefektywniejszych - przy użyciu pętli for oraz jej rozszerzonej wersji.

Iteracja pętlą for

Zapoznajmy się z przykładem iterowania po każdym elemencie listy tablicowej, w którym wykorzystujemy pętlę for.

import java.util.ArrayList;
import java.util.List;

public class Dynamiczne {
    public static void main(String[] args) {
        // Tworzenie listy tablicowej listaTablicowa, która przechowuje obiekty typu Integer
        List<Integer> listaTablicowa = new ArrayList<>();

        // Dodanie elementów do listy
        listaTablicowa.add(5);
        listaTablicowa.add(9);
        listaTablicowa.add(1);
        listaTablicowa.add(8);
        listaTablicowa.add(7);

        // Używanie zwykłej pętli for do iteracji po każdym elemencie listy
        for (int i = 0; i < listaTablicowa.size(); i++) {
            int wyraz = listaTablicowa.get(i); // Pobieranie elementu z listy na indeksie i
            // Wyświetlanie każdego elementu listy oddzielonego spacją
            System.out.print(wyraz + " ");
        }
        // Po zakończeniu pętli lista zostanie wyświetlona w jednej linii w formacie: 5 9 1 8 7 
    }
}

Wynik działania programu:

5 9 1 8 7 	// Wynik działania programu to
    		// wyświetlenie wszystkich elementów listy
    		// w jednej linii oddzielonych spacjami.

Iteracja rozszerzoną pętlą for

W tym przykładzie wykorzystujemy rozszerzoną pętlę for‑each. Rozszerzona pętla for‑each umożliwia prostsze i bardziej czytelne iterowanie po elementach kolekcji, takich jak tablice czy listy, bez konieczności korzystania z tradycyjnej pętli for z indeksami.

Pętla for‑each jest używana w następujący sposób:

for (typ elementu : kolekcja)

W przypadku tego kodu int wyraz : listaTablicowa, typ elementu to int, ponieważ listaTablicowa przechowuje obiekty typu Integer.

Wewnątrz pętli for‑each każdy element wyraz z listy listaTablicowa jest dostępny w każdej iteracji, a kod w bloku pętli może operować na tym elemencie. W tym przypadku każdy element listy jest wyświetlany za pomocą System.out.print(wyraz + " "), co powoduje wyświetlenie elementów listy oddzielonych spacją w jednej linii.

Rozszerzona pętla for‑each jest użyteczna, gdy chcemy przeiterować po wszystkich elementach kolekcji bez konieczności śledzenia indeksów ani długości kolekcji. Jest to prosty i czytelny sposób przeglądania elementów w kolekcji, który pomaga uniknąć błędów związanych z indeksami oraz skraca kod.

import java.util.ArrayList;
import java.util.List;

public class Dynamiczne {
    public static void main(String[] args) {
        // Tworzenie listy tablicowej listaTablicowa, która przechowuje obiekty typu Integer
        List<Integer> listaTablicowa = new ArrayList<>();

        // Dodanie elementów do listy
        listaTablicowa.add(5);
        listaTablicowa.add(9);
        listaTablicowa.add(1);
        listaTablicowa.add(8);
        listaTablicowa.add(7);

        // Używanie pętli for-each do iteracji po każdym elemencie listy
        for (int wyraz : listaTablicowa) {
            // Wyświetlanie każdego elementu listy oddzielonego spacją
            System.out.print(wyraz + " ");
        }
        // Po zakończeniu pętli lista zostanie wyświetlona w jednej linii w formacie: 5 9 1 8 7 
    }
}

Wynik działania programu:

5 9 1 8 7 	// Wynik działania programu to
    		// wyświetlenie wszystkich elementów listy
    		// w jednej linii oddzielonych spacjami.

Słownik

int liczba = 7;