Может ли наследоваться класс от Enum?

Может ли класс наследоваться от Enum

Нет, класс НЕ может наследоваться от Enum в Java. Это одно из ограничений языка. Enum в Java имеет особую природу — Enum автоматически наследуется от java.lang.Enum, и Java не позволяет множественное наследование.

Почему это запрещено

// ❌ Это вызовет ошибку компилятора
class Status extends Enum {
    // Compilation error: cannot extend enum
}

// ❌ Это тоже ошибка
class OrderStatus extends PENDING {
    // PENDING — значение enum, не класс для наследования
}

Считать, почему:

• Enum автоматически extends java.lang.Enum — это заложено в самом языке
• Java запрещает множественное наследование классов — поэтому если бы класс мог extend Enum, то он бы наследовал от двух родителей
• Enum требует особой инициализации — значения enum должны быть определены в самом enum классе

public enum Status {
    PENDING,
    APPROVED,
    REJECTED,
    ARCHIVED;
    
    // Status наследуется от java.lang.Enum неявно
    // Это сделано самим компилятором
}

// Эквивалент того, что компилятор генерирует:
public final class Status extends Enum<Status> {
    public static final Status PENDING = new Status("PENDING", 0);
    public static final Status APPROVED = new Status("APPROVED", 1);
    public static final Status REJECTED = new Status("REJECTED", 2);
    public static final Status ARCHIVED = new Status("ARCHIVED", 3);
    
    private static final Status[] $VALUES = {...};
    
    // Приватный конструктор
    private Status(String name, int ordinal) {
        super(name, ordinal);
    }
}

Что МОЖНО делать вместо наследования

1. Enum с методами и полями

Тебе не нужно наследовать от Enum, потому что сам Enum может содержать методы:

public enum OrderStatus {
    PENDING("заказ ещё обрабатывается", 100) {
        @Override
        public void process(Order order) {
            order.validateItems();
            order.checkPayment();
        }
    },
    
    APPROVED("заказ одобрен", 200) {
        @Override
        public void process(Order order) {
            order.reserveItems();
            order.sendNotification();
        }
    },
    
    SHIPPED("заказ отправлен", 300) {
        @Override
        public void process(Order order) {
            order.updateTrackingInfo();
            order.notifyShipping();
        }
    },
    
    DELIVERED("заказ доставлен", 400) {
        @Override
        public void process(Order order) {
            order.completeOrder();
            order.sendFeedbackRequest();
        }
    };
    
    private final String description;
    private final int code;
    
    // Конструктор
    OrderStatus(String description, int code) {
        this.description = description;
        this.code = code;
    }
    
    // Методы в enum
    public String getDescription() {
        return description;
    }
    
    public int getCode() {
        return code;
    }
    
    public boolean isShipped() {
        return this == SHIPPED || this == DELIVERED;
    }
    
    public boolean isFinal() {
        return this == DELIVERED || this == CANCELLED;
    }
    
    // Абстрактный метод — КАЖДОЕ значение должно его реализовать
    public abstract void process(Order order);
}

// Использование
OrderStatus status = OrderStatus.PENDING;
status.process(myOrder); // Вызовет process для PENDING

2. Enum с интерфейсами (вместо наследования)

Это отличный способ, если нужна общая функциональность:

// Интерфейс
public interface Processable {
    void process(Order order);
    String getDescription();
}

// Enum реализует интерфейс
public enum PaymentStatus implements Processable {
    PENDING("ожидание платежа") {
        @Override
        public void process(Order order) {
            order.requestPayment();
        }
    },
    
    COMPLETED("платёж выполнен") {
        @Override
        public void process(Order order) {
            order.confirmPayment();
        }
    },
    
    FAILED("платёж не прошёл") {
        @Override
        public void process(Order order) {
            order.cancelOrder();
        }
    };
    
    private final String description;
    
    PaymentStatus(String description) {
        this.description = description;
    }
    
    @Override
    public String getDescription() {
        return description;
    }
}

3. Несколько интерфейсов в одном enum

public interface Validatable {
    boolean isValid();
}

public interface Transitionable {
    boolean canTransitionTo(Object nextState);
}

public enum DocumentStatus implements Validatable, Transitionable {
    DRAFT {
        @Override
        public boolean isValid() {
            return false; // Черновик не валиден
        }
        
        @Override
        public boolean canTransitionTo(Object next) {
            return next == SUBMITTED || next == ARCHIVED;
        }
    },
    
    SUBMITTED {
        @Override
        public boolean isValid() {
            return true;
        }
        
        @Override
        public boolean canTransitionTo(Object next) {
            return next == APPROVED || next == REJECTED || next == DRAFT;
        }
    },
    
    APPROVED {
        @Override
        public boolean isValid() {
            return true;
        }
        
        @Override
        public boolean canTransitionTo(Object next) {
            return next == ARCHIVED;
        }
    };
}

4. Enum для策略 паттерна (Strategy Pattern)

public enum DiscountStrategy {
    NO_DISCOUNT(1.0) {
        @Override
        public double applyDiscount(double price) {
            return price;
        }
    },
    
    STUDENT_DISCOUNT(0.9) {
        @Override
        public double applyDiscount(double price) {
            return price * 0.9; // 10% скидка
        }
    },
    
    SENIOR_DISCOUNT(0.85) {
        @Override
        public double applyDiscount(double price) {
            return price * 0.85; // 15% скидка
        }
    },
    
    BLACK_FRIDAY_DISCOUNT(0.5) {
        @Override
        public double applyDiscount(double price) {
            return price * 0.5; // 50% скидка
        }
    };
    
    private final double coefficient;
    
    DiscountStrategy(double coefficient) {
        this.coefficient = coefficient;
    }
    
    public abstract double applyDiscount(double price);
    
    public double getCoefficient() {
        return coefficient;
    }
}

// Использование
price = DiscountStrategy.STUDENT_DISCOUNT.applyDiscount(100); // 90

5. Enum для маппинга значений

public enum HttpStatus {
    OK(200, "OK"),
    CREATED(201, "Created"),
    BAD_REQUEST(400, "Bad Request"),
    UNAUTHORIZED(401, "Unauthorized"),
    FORBIDDEN(403, "Forbidden"),
    NOT_FOUND(404, "Not Found"),
    INTERNAL_SERVER_ERROR(500, "Internal Server Error");
    
    private final int code;
    private final String message;
    
    HttpStatus(int code, String message) {
        this.code = code;
        this.message = message;
    }
    
    public static HttpStatus fromCode(int code) {
        for (HttpStatus status : HttpStatus.values()) {
            if (status.code == code) {
                return status;
            }
        }
        throw new IllegalArgumentException("Unknown status code: " + code);
    }
    
    public boolean isSuccess() {
        return code >= 200 && code < 300;
    }
    
    public boolean isClientError() {
        return code >= 400 && code < 500;
    }
    
    public boolean isServerError() {
        return code >= 500 && code < 600;
    }
}

// Использование
HttpStatus status = HttpStatus.OK;
if (status.isSuccess()) {
    System.out.println("Request successful");
}

Сравнение: Enum vs Класс vs Interface

Практический пример из IKEA

// Статусы заказа с логикой
public enum WarehouseOrderStatus {
    
    RECEIVED("Заказ получен на склад") {
        @Override
        public void execute(WarehouseOrder order) {
            order.registerInSystem();
            order.assignToWarehouse();
        }
        
        @Override
        public WarehouseOrderStatus nextStatus() {
            return PICKING;
        }
    },
    
    PICKING("Товар подбирается") {
        @Override
        public void execute(WarehouseOrder order) {
            order.allocateItems();
            order.generatePickingList();
        }
        
        @Override
        public WarehouseOrderStatus nextStatus() {
            return PACKING;
        }
    },
    
    PACKING("Товар упаковывается") {
        @Override
        public void execute(WarehouseOrder order) {
            order.packItems();
            order.generateLabel();
        }
        
        @Override
        public WarehouseOrderStatus nextStatus() {
            return SHIPPED;
        }
    },
    
    SHIPPED("Товар отправлен") {
        @Override
        public void execute(WarehouseOrder order) {
            order.notifyCarrier();
            order.updateTracking();
        }
        
        @Override
        public WarehouseOrderStatus nextStatus() {
            return DELIVERED;
        }
    };
    
    private final String description;
    
    WarehouseOrderStatus(String description) {
        this.description = description;
    }
    
    public abstract void execute(WarehouseOrder order);
    public abstract WarehouseOrderStatus nextStatus();
    
    public String getDescription() {
        return description;
    }
}

Заключение

• Класс НЕ может наследоваться от Enum — это ограничение Java
• Enum может содержать методы и поля — этого обычно достаточно
• Enum может реализовать интерфейсы — для общей функциональности
• Enum идеален для фиксированного набора значений — Orders, Statuses, Roles

Это одна из сильных сторон Enum в Java — они позволяют тип-безопасные константы с методами, не требуя сложного наследования.