Java Academy · Lekcja

Definiowanie i używanie enumów

Deklaruj typy enum, używaj ich stałych oraz iteruj po nich za pomocą values() i ordinal().

Definiowanie i używanie enumów 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.

Definiowanie i używanie enumów

enum (typ wyliczeniowy) to specjalna klasa reprezentująca stały zestaw stałych. Enumy zapewniają bezpieczeństwo typów, są czytelne i mają większe możliwości niż statyczne stałe typu int.

Deklarowanie enuma

Użyj słowa kluczowego enum, aby zadeklarować typ wyliczeniowy. Każda stała jest niejawnie public static final i stanowi instancję typu enum.

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
    FRIDAY, SATURDAY, SUNDAY
}

Day today = Day.WEDNESDAY;
System.out.println(today);          // WEDNESDAY
System.out.println(today.name());   // WEDNESDAY
System.out.println(today.ordinal()); // 2 (zero-based index)

Iterowanie za pomocą values()

EnumType.values() zwraca wszystkie stałe w kolejności ich deklaracji. Używaj tej metody do iterowania lub tworzenia menu.

enum Planet { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE }

for (Planet p : Planet.values()) {
    System.out.println(p.ordinal() + ": " + p);
}
// 0: MERCURY
// 1: VENUS
// 2: EARTH
// ...

// Count constants
System.out.println(Planet.values().length); // 8

valueOf() i parsowanie

Enum.valueOf(name) konwertuje String na pasującą stałą. Jeśli nie zostanie ona znaleziona, zgłasza IllegalArgumentException.

enum Status { PENDING, ACTIVE, SUSPENDED, CLOSED }

String input = "ACTIVE";
Status s = Status.valueOf(input);
System.out.println(s); // ACTIVE

try {
    Status bad = Status.valueOf("UNKNOWN");
} catch (IllegalArgumentException e) {
    System.out.println("Invalid status: UNKNOWN");
}

// Safe parse pattern
static Status safeFrom(String name) {
    try { return Status.valueOf(name.toUpperCase()); }
    catch (IllegalArgumentException e) { return Status.PENDING; }
}

Używanie enumów w switch

Enumy doskonale współpracują z instrukcjami i wyrażeniami switch. Nowoczesne wyrażenia switch pozwalają zwięźle obsłużyć wszystkie przypadki enumu.

enum OrderStatus { CREATED, PROCESSING, SHIPPED, DELIVERED, CANCELLED }

OrderStatus status = OrderStatus.SHIPPED;

String message = switch (status) {
    case CREATED     -> "Order received, awaiting payment";
    case PROCESSING  -> "Payment confirmed, preparing shipment";
    case SHIPPED     -> "On the way — track your package";
    case DELIVERED   -> "Delivered! Enjoy your order";
    case CANCELLED   -> "Order cancelled";
};
System.out.println(message); // On the way — track your package

Enumy z if/else

Do porównywania stałych enuma używaj == — są one pojedynczymi instancjami, więc porównywanie referencji działa prawidłowo.

enum UserRole { GUEST, MEMBER, ADMIN, SUPERADMIN }

UserRole role = UserRole.ADMIN;

if (role == UserRole.ADMIN || role == UserRole.SUPERADMIN) {
    System.out.println("Access granted to admin panel");
} else {
    System.out.println("Access denied");
}

// Enum comparison: never use .equals() for enums
// == is correct and more readable

Enumy w kolekcjach

Enumy można przechowywać w standardowych kolekcjach. Używaj EnumSet i EnumMap do wydajnego przechowywania danych opartych na enumach (zostanie to omówione w późniejszej lekcji).

import java.util.*;

enum Permission { READ, WRITE, DELETE, ADMIN }

Set<Permission> userPerms = new HashSet<>();
userPerms.add(Permission.READ);
userPerms.add(Permission.WRITE);

System.out.println(userPerms.contains(Permission.DELETE)); // false
System.out.println(userPerms.contains(Permission.READ));   // true

List<Permission> allPerms = Arrays.asList(Permission.values());
System.out.println(allPerms.size()); // 4

Enumy implementują interfejsy

Enumy mogą implementować interfejsy, co pozwala przypisać zachowanie każdej stałej lub zdefiniować wspólny kontrakt dla wszystkich stałych.

interface Describable {
    String describe();
}

enum Season implements Describable {
    SPRING, SUMMER, FALL, WINTER;

    public String describe() {
        return switch (this) {
            case SPRING -> "Mild and rainy";
            case SUMMER -> "Hot and sunny";
            case FALL   -> "Cool with falling leaves";
            case WINTER -> "Cold and snowy";
        };
    }
}

for (Season s : Season.values()) {
    System.out.println(s + ": " + s.describe());
}

Enum jako maszyna stanów

Enumy doskonale nadają się do implementowania maszyn stanów. Każda stała reprezentuje stan, a metody definiują prawidłowe przejścia.

enum TrafficLight {
    RED, YELLOW, GREEN;

    public TrafficLight next() {
        return switch (this) {
            case RED    -> GREEN;
            case GREEN  -> YELLOW;
            case YELLOW -> RED;
        };
    }
}

TrafficLight light = TrafficLight.RED;
for (int i = 0; i < 6; i++) {
    System.out.println(light);
    light = light.next();
}
// RED, GREEN, YELLOW, RED, GREEN, YELLOW

Najlepsze praktyki dotyczące enumów

Podczas używania enumów stosuj następujące dobre praktyki:

Używaj nazw pisanych wielkimi literami dla stałych (konwencja)
Preferuj enumy zamiast stałych typu int lub String, aby zapewnić bezpieczeństwo typów
Używaj wyrażeń switch do wyczerpującej obsługi wszystkich przypadków
Dodawaj pola i metody do enumów, gdy stałe przechowują dane

Praktyka: kody statusów HTTP

Praktyczny enum modelujący kategorie statusów HTTP z metodą fabrykującą na podstawie kodu numerycznego.

enum HttpStatus {
    OK(200), CREATED(201), BAD_REQUEST(400),
    UNAUTHORIZED(401), NOT_FOUND(404), SERVER_ERROR(500);

    public final int code;

    HttpStatus(int code) { this.code = code; }

    public static HttpStatus from(int code) {
        for (HttpStatus s : values())
            if (s.code == code) return s;
        throw new IllegalArgumentException("Unknown HTTP code: " + code);
    }

    public boolean isSuccess() { return code >= 200 && code < 300; }
}

HttpStatus s = HttpStatus.from(404);
System.out.println(s + " (" + s.code + ") success=" + s.isSuccess());
// NOT_FOUND (404) success=false

Szybkie sprawdzenie

Jaki będzie wynik poniższego kodu?

enum Color { RED, GREEN, BLUE }
System.out.println(Color.GREEN.ordinal());

Podsumowanie: definiowanie i używanie enumów

Najważniejsze informacje:

Enumy definiują stały zestaw nazwanych stałych z zapewnieniem bezpieczeństwa typów
values() iteruje po wszystkich stałych; ordinal() zwraca indeks liczony od zera
valueOf() konwertuje String na pasującą stałą
Do porównywania instancji enumów używaj == (a nie equals)
Enumy świetnie sprawdzają się w wyrażeniach switch do wyczerpującej obsługi wszystkich przypadków
Enumy mogą implementować interfejsy, aby przypisywać zachowanie poszczególnym stałym

Często zadawane pytania

Czy lekcja „Definiowanie i używanie enumów” jest bezpłatna?

Tak — pełny tekst „Definiowanie i używanie enumów” 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 „Definiowanie i używanie enumów”?

Deklaruj typy enum, używaj ich stałych oraz iteruj po nich za pomocą values() i ordinal(). Ć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 „Definiowanie i używanie enumów”?

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