Перечисление Java и дополнительные файлы классов

на 1 $и т. д. файлы возникают при использовании функции" реализация метода для каждого экземпляра " перечислений Java, например:

public enum Foo{
    YEA{
        public void foo(){ return true };
    },
    NAY{
        public void foo(){ return false };
    };

    public abstract boolean foo();
}

выше будет создано три файла класса, один для базового класса перечисления и по одному для YEA и NAY для хранения различных реализаций foo().

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

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

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

Я считаю, что это делается для предотвращения разрыва коммутаторов, если порядок перечисления изменяется, не перекомпилируя класс с помощью коммутатора. Рассмотрим следующий случай:

enum A{
    ONE, //ordinal 0
    TWO; //ordinal 1
}
class B{
     void foo(A a){
         switch(a){
              case ONE:
                   System.out.println("One");
                   break;
              case TWO:
                   System.out.println("Two");
                   break;
         }
     }
}

без карты коммутатора,foo() примерно переводится как:

 void foo(A a){
         switch(a.ordinal()){
              case 0: //ONE.ordinal()
                   System.out.println("One");
                   break;
              case 1: //TWO.ordinal()
                   System.out.println("Two");
                   break;
         }
     }

поскольку операторы Case должны быть константами времени компиляции (например, не вызовы методов). В этом случае, если заказ A включается, foo() будет печатать "один" для двух, и наоборот.

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

поэтому в любое время, когда вы определяете новое перечисление, компилятор Java создаст для вас соответствующий файл класса. (Независимо от того, насколько просто перечисление).

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

Если пространство ограничено, вы всегда можете просто использовать константы.

насколько я знаю, учитывая перечисление с именем Operation вы получите дополнительные файлы класса, исключая очевидный Operation.class, и один на значение перечисления, если вы используете abstract method вот так:

enum Operation {

   ADD {
      double op(double a, double b) { 
          return a + b;
      }
   },

   SUB {
      double op(double a, double b) { 
          return a - b;
      }
   };

   abstract double op(double a, double b);
}