Подробное введение в типы перечислений в Java

В перечислении есть метод значений, который используется для генерации массива в порядке, определенном перечислением, который можно использовать для обхода. Все наши пользовательские классы перечисления наследуют от java.lang.Enum и в примерах имеют следующие функции:

Мы также можем использовать статические ссылки перечисления:

Помимо добавления в перечисление методов, которые не могут быть унаследованы, перечисление можно рассматривать как общий класс, а это означает, что вы можете добавлять в перечисление методы, а также определять в перечислении основной метод:


Перечисления в операторах переключения Важная роль перечислений в операторах переключения. Обычно операторы переключения работают только с целочисленными значениями, но в перечислениях имеется встроенный порядок целых чисел, поэтому порядок экземпляров можно определить с помощью какого-либо метода. поэтому перечисления можно использовать в операторах переключения:

Секрет значений() Хотя раньше мы использовали метод значений, если мы посмотрим на Enum, мы не обнаружим метод значений. Итак, есть ли другие скрытые методы? Мы можем проверить это с помощью простого кода отражения:

Мы видим, что метод значений добавлен компилятором. Метод valueOf также добавляется компилятором при создании перечисления, но в классе Enum также есть метод valueOf, но этот метод имеет два параметра, тогда как метод valueOf, добавленный компилятором, имеет только один параметр. Перечисления интерпретируются компилятором как окончательные, поэтому перечисления не могут быть унаследованы. Поскольку метод значений — это статический метод, добавленный компилятором, если вы приведете перечисление к Enum, метод значений будет недоступен, но в классе есть метод getEnumConstants, поэтому, хотя метод значений есть недоступен в Enum, но вы все равно можете получить экземпляр перечисления через объект Class:

Реализация без наследования. Поскольку все типы перечислений, которые мы определяем, наследуются от java.lang.Enum, а Java не поддерживает множественное наследование, поэтому перечисления не создаются посредством наследования, но перечисления могут быть созданы путем наследования одного или нескольких интерфейсов:

Случайный выбор. Во многих наших примерах ниже мы будем случайным образом выбирать объекты из экземпляров перечисления. Для реализации этого мы создаем общедоступный класс:


Использование интерфейсов для организации перечислений не может быть унаследовано, что иногда доставляет нам неудобства, поскольку иногда мы хотим расширить количество перечислений за счет наследования, а иногда нам нужно сгруппировать перечисления. В последнем случае мы можем определить сгруппированные перечисления в интерфейсе, а затем создать перечисление, унаследовав его от этого интерфейса. Таким образом, у нас есть разные категории продуктов питания, которые необходимо создать как перечисления, но нам нужно определить каждую категорию как типы. продуктов питания следующие:

Поскольку каждое перечисление определяется как реализация интерфейса, каждое перечисление имеет тип Food следующим образом:

Но интерфейсы не могут работать с несколькими типами, например перечисления, поэтому, если вам нужно перечисление перечислений, вы можете инкапсулировать экземпляр каждого типа перечисления в перечислении:

Каждое перечисление использует объект Class в качестве соответствующего параметра конструктора. Мы можем использовать getEnumConstants из этого параметра для получения экземпляра перечисления. Этот экземпляр можно использовать в методе randomSelection для генерации случайных блюд:

Вот более компактная реализация:


Используйте EnumSet вместо флагов EnumSet был добавлен в Java SE5 для объединения перечислений и наборов для замены битовых флагов на основе целых чисел. Битовые флаги обычно используются для обозначения переключения какой-либо информации, но в коде оперируют битами, а не значимыми понятиями, поэтому их нелегко понять. EnumSet работает быстрее, чем битовые флаги. Он внутренне использует long для представления битового вектора, а затем вы можете использовать более концептуальный язык для представления переключения определенного бита, не беспокоясь об эффективности. Элементы в EnumSet должны происходить из одного и того же перечисления. Следующее определяет перечисление позиции тревоги:

Затем используйте класс EnumSet для отслеживания статуса сигнала тревоги:

EnumSet построен на длинном типе и имеет 64 бита, так что, если наш тип перечисления превышает это число?

Мы видим, что программа работает нормально, поэтому вполне вероятно, что тип long был добавлен внутри, чтобы помочь разместить тип перечисления с помощью EnumMap.
EnumMap — это особый тип Map. Значение его ключа может быть только типом того же перечисления. По этой причине EnumMap можно реализовать внутри через массив, что очень эффективно.

Конкретные константные методы Перечисления Java имеют очень интересную особенность: для каждого экземпляра перечисления можно определить различное поведение. Чтобы добиться этого, мы определяем один или несколько абстрактных методов как часть перечисления, а затем определяем различное поведение для каждого. Экземпляр перечисления Метод определения экземпляра перечисления:

Кажется, что приведенный выше код застрял в том, что каждый элемент перечисления является отдельным элементом, и все элементы наследуются от базового класса ConstantSpecificMethod, но мы не можем понять это таким образом, потому что мы не можем рассматривать элементы перечисления как типы:

Рассмотрим другой пример. Клиенты выбирают разные услуги на основе разных меню. Вы можете использовать определенные константные методы, чтобы связать меню с услугами, и использовать EnumSet для сохранения выбора клиента, как показано ниже.

Мы также можем переопределить конкретные константные методы по умолчанию вместо использования унаследованных абстрактных методов следующим образом:

Иногда нам нужно передать определенные запросы в цепочке. Зная, что объект в цепочке может обработать запрос, можно легко добиться, используя определенные константные методы. Ниже приведен пример обработки электронных писем.

Тип перечисления также является идеальным типом для создания конечного автомата. Конечный автомат может перемещаться между ограниченным количеством состояний в соответствии с входными данными, а затем завершать работу после достижения определенного состояния. Соответствующий вывод Торговый автомат — это пример типичного конечного автомата, в котором мы определяем различные входные данные внутри перечисления:

VendingMachine используется для ответа на ввод. Сначала он классифицирует ввод посредством перечисления категорий, а затем использует оператор переключения:

Вот тестовые данные, использованные для генерации приведенного выше вывода:

Множественная распаковка При взаимодействии между несколькими типами код, скорее всего, станет беспорядочным, например Number.plush(Number), Number.mutiply(Number) и т. д. Number — это всего лишь базовый класс семейства, поэтому при вызове Когда a.plus(b), вы не знаете ни тип a, ни тип b, так как же гарантировать, что взаимодействие между ними правильное? Java может выполнять только однократную распаковку, то есть, если выполняется одна или несколько операций с несколькими неизвестными типами, Java может выполнить только механизм динамической привязки к одному из типов, что не может решить проблему, о которой мы говорили выше, поэтому у вас есть. чтобы вручную написать код динамической привязки.
Решение — использовать мультипривязку. Полиморфизм может возникнуть только при вызове метода, поэтому если вам нужно несколько распаковок, вам придется вызвать несколько методов. При множественной развертке у вас должен быть виртуальный метод, который вызывает метод каждого типа для развертывания. Следующий пример представляет собой пример «камень-ножницы-бумага»:

Мы использовали много методов для достижения множественной распаковки, но то, что мы получили, было хорошей структурой кода. Самая большая проблема при использовании решения перечисления для реализации вышеуказанного кода заключается в том, что экземпляр перечисления не является типом, поэтому экземпляр перечисления не может использоваться в качестве типа параметра. Но у нас все еще есть другие способы обойти это препятствие.



Поскольку формулирование статических методов может обеспечить различные методы для каждого типа перечисления, это кажется хорошим решением для достижения множественной распаковки, но мы все еще сталкиваемся с проблемой, что экземпляр перечисления не является типом, поэтому все, что мы можем сделать, это добавить оператор переключателя :

Следующий код является более кратким методом реализации:

Класс Enummap, кажется, является хорошим способом реализовать множественные распаковки:

Мы также можем использовать функцию экземпляров перечисления с фиксированными значениями для использования данных для простейшего метода реализации.