Какая польза от "перечисления" в Java? [дубликат]

использовать enum вместо class если класс должен иметь фиксированный перечислениеerable количество экземпляров.

примеры:

• DayOfWeek = 7 экземпляров → enum
• CardSuit = 4 экземплярах → enum
• Singleton = 1 экземпляра → enum
  
  
• Product = переменное число экземпляров → class
• User = переменное число экземпляров → class
• Date = переменное число экземпляров → class

перечисляемый тип-это в основном тип данных, который позволяет описывать каждый член типа более читаемым и надежным способом.

вот простой пример, чтобы объяснить, почему:

предполагая, что вы пишете метод, который имеет какое-то отношение к сезонам:

int enum pattern

во-первых, вы объявили некоторые статические константы int для представления каждого сезона.

public static final int SPRING = 0;
public static final int SUMMER = 1;
public static final int FALL = 2;
public static final int WINTER = 2;

затем вы объявили метод для печати имени сезон в консоли.

public void printSeason(int seasonCode) {
    String name = "";
    if (seasonCode == SPRING) {
        name = "Spring";
    }
    else if (seasonCode == SUMMER) {
        name = "Summer";
    }
    else if (seasonCode == FALL) {
        name = "Fall";
    }
    else if (seasonCode == WINTER) {
        name = "Winter";
    }
    System.out.println("It is " + name + " now!");
}

Итак, после этого вы можете напечатать имя, сезон такой.

printSeason(SPRING);
printSeason(WINTER);

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

printSeason(0);
printSeason(1);

или даже вот так

printSeason(x - y);
printSeason(10000);

компилятор не будет жаловаться, потому что эти вызовы метода допустимыми, и ваш printSeason способ все еще может работать.

но что-то здесь не так. Что делает сезон код 10000 значит? А что если x - y приводит к отрицательному числу? Когда ваш метод получает вход, который не имеет смысла и не должен быть там, ваша программа ничего не знает об этом.

вы можете исправить эту проблему, например, добавить дополнительную проверку.

...
else if (seasonCode == WINTER) {
    name = "Winter";
}
else {
    throw new IllegalArgumentException();
}
System.out.println(name);

теперь программа будет кидать RunTimeException когда сезон код является недопустимым. Однако вам все равно нужно решить, как вы собираетесь обрабатывать исключение.

кстати, я уверен, что вы заметили код FALL и WINTER в 2, верно?

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

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

вот когда enum вступает в игру.

---

использовать enum тип

В Java, enum типы-это классы, которые экспортируют один экземпляр для каждой константы перечисления через открытое статическое конечное поле.

здесь вы можете объявить четыре константы перечисления: SPRING, SUMMER, FALL, WINTER. У каждого своя name.

public enum Season {
    SPRING("Spring"), SUMMER("Summer"), FALL("Fall"), WINTER("Winter");

    private String name;

    Season(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

теперь вернемся к методу.

public void printSeason(Season season) {
    System.out.println("It is " + season.getName() + " now!");
}

вместо int, теперь вы можете использовать Season в качестве входных данных. Вместо проверки состояния, вы можете сказать Season чтобы дать вам свое имя.

вот как вы используете этот метод сейчас:

printSeason(Season.SPRING);
printSeason(Season.WINTER);
printSeason(Season.WHATEVER); <-- compile error

вы получите ошибку времени компиляции при использовании неправильного ввода, и вы гарантированно получите ненулевую одноэлементную ссылку Season пока программа составляет.

когда нам нужен дополнительный сезон, мы просто добавить еще одну константу в Season и не более.

public enum Season {
    SPRING("Spring"), SUMMER("Summer"), FALL("Fall"), WINTER("Winter"), 
    MYSEASON("My Season");

...

---

всякий раз, когда вам нужен фиксированный набор констант, enum может быть хорошим выбором (но не всегда). Это более читаемое, более надежное и более мощное решение.

тип перечисления-это тип, поля которого состоят из фиксированного набора констант. Общие примеры включают направления компаса (значения севера, юга, востока и Запада) и дни недели.

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

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

вот некоторый код, который показывает вам, как использовать перечисление дня, определенное выше:

public class EnumTest {
    Day day;

    public EnumTest(Day day) {
        this.day = day;
    }

    public void tellItLikeItIs() {
        switch (day) {
            case MONDAY:
                System.out.println("Mondays are bad.");
                break;

            case FRIDAY:
                System.out.println("Fridays are better.");
                break;

            case SATURDAY: case SUNDAY:
                System.out.println("Weekends are best.");
                break;

            default:
                System.out.println("Midweek days are so-so.");
                break;
        }
    }

    public static void main(String[] args) {
        EnumTest firstDay = new EnumTest(Day.MONDAY);
        firstDay.tellItLikeItIs();
        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
        thirdDay.tellItLikeItIs();
        EnumTest fifthDay = new EnumTest(Day.FRIDAY);
        fifthDay.tellItLikeItIs();
        EnumTest sixthDay = new EnumTest(Day.SATURDAY);
        sixthDay.tellItLikeItIs();
        EnumTest seventhDay = new EnumTest(Day.SUNDAY);
        seventhDay.tellItLikeItIs();
    }
}

выход:

по понедельникам плохо.
в середине недели дни так себе.
пятница лучше.
лучше на выходных.
лучше на выходных.

типы перечислений языка программирования Java намного мощнее, чем их аналоги на других языках. Объявление перечисления определяет класс (называемый тип enum.) Тело класса enum может включать методы и другие поля. Компилятор автоматически добавляет некоторые специальные методы при создании перечисления. Например, у них есть метод статических значений, который возвращает массив, содержащий все значения перечисления в том порядке, в котором они объявлены. Этот метод обычно используется в сочетании с конструкцией for-each для итерации по значениям типа перечисления. Например, этот код из приведенного ниже примера класса Planet выполняет итерацию по всем планетам в солнечная система.

for (Planet p : Planet.values()) {
    System.out.printf("Your weight on %s is %f%n",
                      p, p.surfaceWeight(mass));
}

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

public 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),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }
}

если вы запустите Planet.класс из командной строки с аргументом 175, вы получаете этот вывод:

$ планета Ява 175
ваш вес на Меркурии составляет 66.107583
ваш вес на Венере составляет 158,374842
ваш вес на земле 175.000000
ваш вес на Марсе составляет 66.279007
ваш вес на Юпитере составляет 442.847567
ваш вес на Сатурне составляет 186,552719
ваш вес на Уране составляет 158,397260
ваш вес на Нептуне составляет 199.207413

источник: http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

перечисление является безопасным типом, поэтому вы не можете назначить новое значение во время выполнения. Кроме того, вы можете использовать его в операторе switch (как целое).

перечислений являются рекомендуется чтобы обеспечить легко запоминаемые имена для определенного набора контентов (необязательно с некоторым ограниченным поведением тоже).

вы должны использовать перечисления, где в противном случае можно использовать несколько статических констант (например. public static int ROLE_ADMIN = 0 или BLOOD_TYPE_AB = 2)

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

язык программирования Java enums гораздо более мощные, чем их аналоги в других языках, которые немного больше, чем прославленные целые числа. Новое объявление перечисления определяет полноценный класс (называемый типом перечисления). В дополнение к решению всех проблем(Not typesafe, No namespace, Brittleness and Printed values are uninformative), который существует со следующим шаблоном перечисления int, который использовался до java 5.0:

public static final int SEASON_WINTER = 0;

он также позволяет добавлять произвольные методы и поля в тип перечисления, чтобы реализовать произвольные интерфейсы и многое другое. Типы перечислений обеспечивают высококачественные реализации всех методов объекта. Они Comparable и Serializable, и серийная форма конструирована для того чтобы выдержать произвольные изменения в типе перечисления. Вы также можете использовать перечисление в switch случае.

прочитайте полную статью о перечислениях Java http://docs.oracle.com/javase/1.5.0/docs/guide/language/enums.html для более подробной информации.

1) enum-это ключевое слово в объектно-ориентированный способ.

2) он используется для написания кода в одной строке, вот и все.

     public class NAME
     {
        public static final String THUNNE = "";
        public static final String SHAATA = ""; 
        public static final String THULLU = ""; 
     }

-------This can be replaced by--------

  enum NAME{THUNNE, SHAATA, THULLU}

3) Большинство разработчиков не используют ключевое слово enum, это просто альтернативный метод..