Java Academy · Lekcja

Typy proste a typy referencyjne

Poznaj fundamentalną różnicę między typami prostymi a typami referencyjnymi w Javie.

Typy proste a typy referencyjne to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Typy prymitywne a typy referencyjne

Java ma dwie podstawowe kategorie typów danych: typy prymitywne i typy referencyjne. Zrozumienie tej różnicy ma kluczowe znaczenie dla pisania poprawnego i wydajnego kodu Java.

Osiem typów prymitywnych

Java ma dokładnie osiem typów prymitywnych:

byte (8-bitowa liczba całkowita)
short (16-bitowa liczba całkowita)
int (32-bitowa liczba całkowita)
long (64-bitowa liczba całkowita)
float (32-bitowa liczba zmiennoprzecinkowa)
double (64-bitowa liczba zmiennoprzecinkowa)
char (16-bitowy znak Unicode)
boolean (prawda/fałsz)

Typy prymitywne przechowują wartość bezpośrednio w pamięci — bez narzutu obiektu.

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

Typy referencyjne

Typ referencyjny przechowuje adres pamięci (referencję) wskazujący na obiekt na stercie. Obejmuje to:

Klasy (np. String, Scanner)
Tablice (np. int[])
Interfejsy
Typy wyliczeniowe i rekordy

Zmienna nie przechowuje obiektu — przechowuje wskaźnik do niego.

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

Pamięć stosu a sterty

Zmienne prymitywne są przechowywane na stosie — w szybkiej, krótkotrwałej pamięci związanej z wywołaniami metod.

Obiekty typów referencyjnych znajdują się na stercie — w większej, długotrwałej pamięci zarządzanej przez garbage collection. Sama referencja (adres) znajduje się na stosie.

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null: brak referencji

Zmiennym referencyjnym można przypisać null, co oznacza, że nie wskazują na żaden obiekt. Typom prymitywnym nie można przypisać wartości null — zawsze mają jakąś wartość.

Uzyskanie dostępu przez referencję o wartości null powoduje NullPointerException (NPE) — jeden z najczęstszych błędów wykonania w Javie.

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

Semantyka kopiowania: typy prymitywne

Po przypisaniu jednej zmiennej prymitywnej do drugiej Java kopiuje wartość. Zmiana jednej zmiennej nie wpływa na drugą — są całkowicie niezależne.

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

Semantyka kopiowania: referencje

Po przypisaniu jednej zmiennej referencyjnej do drugiej obie zmienne wskazują na ten sam obiekt. Modyfikacja obiektu za pośrednictwem jednej referencji jest widoczna za pośrednictwem drugiej.

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

Klasy opakowujące: boxing typów prymitywnych

Każdy typ prymitywny ma odpowiadającą mu klasę opakowującą w pakiecie java.lang:

int → Integer
double → Double
boolean → Boolean
char → Character

Klasy opakowujące pozwalają używać typów prymitywnych jako obiektów — jest to wymagane w kolekcjach takich jak List<Integer>.

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

Pułapki autoboxingu

Autoboxing jest wygodny, ale może powodować trudne do zauważenia błędy. Integer przechowuje w pamięci podręcznej wartości od -128 do 127 — poza tym zakresem == porównuje referencje, a nie wartości.

Do porównywania obiektów opakowujących należy zawsze używać .equals().

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

Przekazywanie do metod: przekazywanie przez wartość

Java zawsze stosuje przekazywanie przez wartość. W przypadku typów prymitywnych kopiowana jest wartość. W przypadku referencji kopiowana jest referencja (adres) — obie zmienne wskazują na ten sam obiekt, ale nie można ponownie przypisać zmiennej wywołującego z wnętrza metody.

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

Praktyczna tabela podsumowująca

Podręczne zestawienie porównujące typy prymitywne i referencyjne:

Przechowywanie: typ prymitywny → wartość na stosie; typ referencyjny → adres na stosie + obiekt na stercie
Wartość domyślna: typ prymitywny → 0/false/\u0000; typ referencyjny → null
Czy może mieć wartość null: typ prymitywny → Nie; typ referencyjny → Tak
Co jest kopiowane przy przypisaniu: typ prymitywny → wartość; typ referencyjny → adres
W kolekcjach: typy prymitywne wymagają klas opakowujących

Szybkie sprawdzenie

Co się stanie po wykonaniu poniższego kodu?

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

Podsumowanie: typy prymitywne a typy referencyjne

Najważniejsze informacje z tej lekcji:

Java ma 8 typów prymitywnych przechowywanych bezpośrednio na stosie
Typy referencyjne przechowują adres obiektu na stercie; zmienna zawiera ten adres
Typy prymitywne są kopiowane przez wartość; referencje są kopiowane przez adres
Zmienne referencyjne mogą mieć wartość null; typy prymitywne nie mogą
Klasy opakowujące (Integer, Double itd.) opakowują typy prymitywne jako obiekty
Java zawsze stosuje przekazywanie przez wartość — nawet podczas przekazywania referencji

Często zadawane pytania

Czy lekcja „Typy proste a typy referencyjne” jest bezpłatna?

Tak — pełny tekst „Typy proste a typy referencyjne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Typy proste a typy referencyjne”?

Poznaj fundamentalną różnicę między typami prostymi a typami referencyjnymi w Javie. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Typy proste a typy referencyjne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy