0Pricing
Java Academy · Lekcja

Enumy z polami i metodami

Dodawaj pola, konstruktory i metody do enumów, aby hermetyzować ich zachowanie.

Enumy z polami i metodami to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 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.

Enumy z polami i metodami

Stałe enuma mogą przechowywać dane. Pola dodaje się przez ich zadeklarowanie i zdefiniowanie konstruktora. Konstruktor jest automatycznie prywatny.

Deklarowanie pól w enumach

Podczas ładowania klasy każda stała enuma wywołuje konstruktor. Wartości pól są ustawiane raz i pozostają niezmienne (gdy pola zadeklarowano jako final).

enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS  (4.869e+24, 6.0518e6),
    EARTH  (5.976e+24, 6.37814e6),
    MARS   (6.421e+23, 3.3972e6);

    private final double mass;    // kilograms
    private final double radius;  // meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double mass()   { return mass; }
    public double radius() { return radius; }
}

Dodawanie metod do enumów

Typy enum mogą zawierać dowolne metody, które można umieścić w klasie, w tym właściwości obliczane.

enum Planet {
    EARTH(5.976e+24, 6.37814e6);
    // ... constructor and fields ...
    static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }

    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

double earthWeight = 75.0;
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values())
    System.out.printf("Weight on %s: %.2f%n", p, p.surfaceWeight(mass));

Metody abstrakcyjne w stałych enumów

Każda stała może dostarczyć własną implementację metody abstrakcyjnej zadeklarowanej w treści enuma.

enum Operation {
    PLUS  { public double apply(double x, double y) { return x + y; } },
    MINUS { public double apply(double x, double y) { return x - y; } },
    TIMES { public double apply(double x, double y) { return x * y; } },
    DIVIDE{ public double apply(double x, double y) { return x / y; } };

    public abstract double apply(double x, double y);
}

System.out.println(Operation.PLUS.apply(3, 4));   // 7.0
System.out.println(Operation.TIMES.apply(3, 4));  // 12.0

Enumy z etykietami tekstowymi

Często stosowany wzorzec: każdej stałej przypisuje się czytelną dla człowieka etykietę przechowywaną w polu.

enum UserRole {
    GUEST("Guest User"),
    MEMBER("Registered Member"),
    ADMIN("Administrator"),
    SUPERADMIN("Super Administrator");

    private final String label;

    UserRole(String label) { this.label = label; }

    public String label() { return label; }

    public static UserRole fromLabel(String lbl) {
        for (UserRole r : values())
            if (r.label.equalsIgnoreCase(lbl)) return r;
        throw new IllegalArgumentException(lbl);
    }
}

System.out.println(UserRole.ADMIN.label()); // Administrator

Enum z wieloma polami

Enumy mogą mieć tyle pól, ile potrzeba. W tym przypadku enum waluty przechowuje zarówno kod ISO, jak i symbol.

enum Currency {
    USD("US Dollar", "$"),
    EUR("Euro", "\u20ac"),
    GBP("British Pound", "\u00a3"),
    JPY("Japanese Yen", "\u00a5");

    public final String name;
    public final String symbol;

    Currency(String name, String symbol) {
        this.name = name;
        this.symbol = symbol;
    }

    public String format(double amount) {
        return String.format("%s%.2f", symbol, amount);
    }
}

System.out.println(Currency.EUR.format(99.99)); // \u20ac99.99

Nadpisywanie toString()

Nadpisz toString() w enumie, aby zwracał własną reprezentację tekstową zamiast nazwy stałej.

enum HttpMethod {
    GET, POST, PUT, PATCH, DELETE;

    @Override
    public String toString() {
        return name().toUpperCase();
    }

    public boolean hasBody() {
        return this == POST || this == PUT || this == PATCH;
    }
}

HttpMethod m = HttpMethod.POST;
System.out.println(m);            // POST
System.out.println(m.hasBody());  // true
System.out.println(HttpMethod.GET.hasBody()); // false

Enum z walidacją

Konstruktory enumów mogą sprawdzać argumenty, aby zapobiegać nieprawidłowym stanom.

enum DiscountTier {
    BRONZE(5), SILVER(10), GOLD(20), PLATINUM(30);

    public final int percentage;

    DiscountTier(int percentage) {
        if (percentage < 0 || percentage > 100)
            throw new IllegalArgumentException("Invalid: " + percentage);
        this.percentage = percentage;
    }

    public double apply(double price) {
        return price * (1 - percentage / 100.0);
    }
}

System.out.println(DiscountTier.GOLD.apply(100.0)); // 80.0

Wzorzec Singleton z użyciem enuma

Enum zawierający jedną stałą to najbezpieczniejszy sposób implementacji wzorca Singleton w Javie — domyślnie jest bezpieczny podczas serializacji i bezpieczny wątkowo.

enum AppConfig {
    INSTANCE;

    private String dbUrl = "jdbc:postgresql://localhost/mydb";
    private int maxConnections = 20;

    public String getDbUrl() { return dbUrl; }
    public int getMaxConnections() { return maxConnections; }

    public void setDbUrl(String url) { this.dbUrl = url; }
}

// Access the singleton
AppConfig config = AppConfig.INSTANCE;
System.out.println(config.getDbUrl());

Enumy w modelach domenowych

Enumy są powszechnie używane w modelach domenowych do reprezentowania kategorii z zapewnieniem bezpieczeństwa typów: statusu zamówienia, metody płatności, typu powiadomienia itp.

enum PaymentMethod {
    CREDIT_CARD("Credit Card", true),
    DEBIT_CARD("Debit Card", true),
    PAYPAL("PayPal", false),
    CRYPTO("Cryptocurrency", false),
    BANK_TRANSFER("Bank Transfer", false);

    public final String displayName;
    public final boolean instantCharge;

    PaymentMethod(String displayName, boolean instantCharge) {
        this.displayName = displayName;
        this.instantCharge = instantCharge;
    }
}

Pole enuma a wartość obliczana

Pola przechowują stałe dane, a metody obliczają wartości dynamiczne. Używaj pól dla danych stałych, a metod dla wartości pochodnych.

enum DayType {
    MONDAY(false), TUESDAY(false), WEDNESDAY(false),
    THURSDAY(false), FRIDAY(false),
    SATURDAY(true), SUNDAY(true);

    private final boolean weekend;
    DayType(boolean weekend) { this.weekend = weekend; }

    public boolean isWeekend()  { return weekend; }
    public boolean isWeekday()  { return !weekend; }

    public static long weekdayCount() {
        return java.util.Arrays.stream(values())
            .filter(DayType::isWeekday).count();
    }
}
System.out.println(DayType.weekdayCount()); // 5

Szybkie sprawdzenie

Czym konstruktor enuma różni się od konstruktora zwykłej klasy?

Podsumowanie: enumy z polami i metodami

Najważniejsze informacje:

  • Dodaj pola i konstruktor, aby przechowywać dane dla poszczególnych stałych
  • Konstruktory enumów są niejawnie prywatne
  • Metody abstrakcyjne pozwalają każdej stałej dostarczyć własną implementację
  • Nadpisz toString(), aby używać własnych nazw wyświetlanych
  • Enumy zawierające jedną stałą to najlepsza implementacja wzorca Singleton
  • Enumy naturalnie pasują do modeli domenowych jako kategorie zapewniające bezpieczeństwo typów

Często zadawane pytania

Czy lekcja „Enumy z polami i metodami” jest bezpłatna?

Tak — pełny tekst „Enumy z polami i metodami” 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 „Enumy z polami i metodami”?

Dodawaj pola, konstruktory i metody do enumów, aby hermetyzować ich zachowanie. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Enumy z polami i metodami”?

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

  1. Definiowanie i używanie enumów
  2. Enumy z polami i metodami
  3. Wyrażenia switch z enumami
  4. EnumSet i EnumMap
← Powrót do Java Academy