Question

请查看Synthetic Arguments。枚举构造函数有两个额外的合成参数。

请查看以下部分：

另一个例子：Java枚举类

如您所见，它节省了相当多的代码，但也添加了合成字段，方法和构造函数参数。如果您已经使用自己的一组参数定义了自己的构造函数。

是否存在枚举构造函数没有任何合成参数的情况。

抱歉没有提供足够的细节。

Answer 1

阅读完文章后，我会说答案是肯定的。文章解释了一个典型的枚举，例如：

enum Colours {
    RED, BLUE;
}

变为：

final class Colours extends java.lang.Enum {
    public final static Colours RED = new Colours("RED", 0);
    public final static Colours BLUE = new Colours("BLUE", 1);

    private final static values = new Colours[]{ RED, BLUE };

    private Colours(String name, int sequence){
        super(name, sequence);
    }

    public static Colours[] values(){
        return values;
    }

    public static Colours valueOf(String name){
        return (Colours)java.lang.Enum.valueOf(Colours.class, name);
    }
}

其中Colours构造函数的参数被认为是合成（即它们是由编译器生成的，以确保“东西工作”）。所以似乎合成论证是不可避免的，因为它们是将枚举翻译成真实类的必要部分。

唯一的可能性是如果枚举没有值 - Java是否仍然创建合成字段？直觉上，答案是肯定的。这可以通过确定中的文章进行备份，但我为什么要关心？部分。在这里，作者表明，当用反射查看时，空枚举的参数计数仍为2。

Answer 2

检查TimeUnit的Concurrent类的源代码。这是一个有自己方法的枚举。你可以使用enums，就像他们自己上课一样。

http://fuseyism.com/classpath/doc/java/util/concurrent/TimeUnit-source.html

以下是我的一个例子：

public enum ExampleEnum {
    ENUM_1 ( "ENUM_1", 1, Color.GREEN ) {
        @Override
        public void doMethingWeird( String stringToEnum ) {
            //Implementation goes here;
        }
    }, 
    ENUM_2 ( "ENUM_2", 2, Color.BLACK ) {
        @Override
        public void doMethingWeird( String stringToEnum ) {
            //Implementation goes here;
        }
    }, 
    ENUM_3 ( "ENUM_3", 3, Color.WHITE ){
        @Override
        public void doMethingWeird( String stringToEnum ) {
            //Implementation goes here;
        }
    };    //Don't forget the semicolon ';' after the enums, to separate them from the methods;

    //You can have static constants;
    private static final Object object = new Object();

    private final String enumName;
    private final int enumNumber;
    private final Color enumColor;  //why not?

    //CONSTRUCTOR IT MUST BE PRIVATE
    private Effect( String enumName, int enumNumber, Color enumColor ){
            this.enumName = enumName;
            this.enumNumber = enumNumber;
            this.enumColor = enumColor;
    }

    //you can have abstract methods and implement them on the enums.
    public abstract void public void doMethingWeird( String stringToEnum );

    public String getEnumName() {
            return enuName;
    }

    public int getEnumNumber() {
            return enumNumber;
    }

    public Color getEnumColor() {
            return enumColor;
    }
}

我希望我有所帮助。

Answer 3

我遇到了同样的问题，有一个带有树构造函数和参数的枚举。进行反射并获取构造函数参数，您将得到一个String和一个额外的int作为前两个参数。我想知道他们来自哪里。调试后我发现Enum类有一个受保护的构造函数，它使用前两个参数。

我通过添加没有参数的构造函数进行了测试，并且还添加了2个额外参数。

Enum.java中带有构造函数的代码：

/**
 * Sole constructor.  Programmers cannot invoke this constructor.
 * It is for use by code emitted by the compiler in response to
 * enum type declarations.
 *
 * @param name - The name of this enum constant, which is the identifier
 *               used to declare it.
 * @param ordinal - The ordinal of this enumeration constant (its position
 *         in the enum declaration, where the initial constant is assigned
 *         an ordinal of zero).
 */
protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

要检测这种情况，可以使用反射构造函数的isEnum（）方法，并跳过2个参数。

Constructor<?> constructor;

private boolean isEnum() {
    return constructor.getDeclaringClass().isEnum();
}

Java枚举构造函数的合成参数

3 个答案: