Java enum synthetic arguments for constructors

Question

Please have a look at Synthetic Arguments. Enum constructors have two additional synthetic arguments.

Please look at the section:

Another example: Java enum classes

As you can see, it saves quite some code, but also adds synthetic fields, methods and constructor parameters. If you had defined your own constructor, with its own set of parameters.

Can there be a situation where a enum constructor does not have any synthetic arguments.

Apologies for not providing enough detail.

I can't find any synthetic arguments in this article. Consider editing your question with appropriate example so we would know what your question actually is about. — Pshemo, Jun 09 '14 at 14:35
@Pshemo The information *is* in there, but I agree it's rather frustrating to read a long article just to understand the question. The code example provided in this question makes little sense to me though. — Duncan Jones, Jun 09 '14 at 14:43

score 1 · Accepted Answer · answered Jun 09 '14 at 14:41

Having read the article, I would say the answer is no. The article explains that a typical enum such as:

enum Colours {
    RED, BLUE;
}

Becomes:

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);
    }
}

where the arguments to the Colours constructor are considered synthetic (i.e. they've been produced by the compiler to make sure "stuff works"). So it seems the synthetic arguments are unavoidable as they're a necessary part of translating an enum into a real class.

The only possibility is if the enum has no values - does Java still create the synthetic fields? Intuitively, the answer is yes. This is backed up by the article in the OK, but why should I care? section. Here the author shows that an empty enum still has a parameter count of two, when viewed with reflection.

score 1 · Answer 2 · answered Jun 09 '14 at 15:04

Check the source code of the Concurrent class of TimeUnit. It's an enum with its own methods. You can have work with enums like if they were class themselves.

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

Here is an example of mine:

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;
    }
}

I hope I have helped.

I meant "doSomethingWeird", and not "doMethingWeird". But I hope it helps. — saclyr, Jun 09 '14 at 15:05

Arjen Rodenhuis · Answer 3 · 2015-03-13T22:05:14.297

I was running into the same problem, having an enum with tree constructors and parameters. Doing reflection and getting the constructors parameters, you get a String and an int extra as the first 2 parameters. I was wondering where they were coming from. After debugging I found out that the Enum class has a protected constructor, which is using the first 2 parameters.

I did a test by adding a constructor without parameters, and the 2 extra parameters are added too.

Code from Enum.java with the constructor:

/**
 * 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;
}

To detect this situation, you can use the isEnum() method of the reflected constructor, and skip the 2 parameters.

Constructor<?> constructor;

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

Java enum synthetic arguments for constructors

3 Answers3