Constructor in enum

[Deepak Bobal]

enum color {

    RED("RRR"), YELLOW("YYY"), GREEN("GGG");

    color(String col) {
        this.col = col;
        System.out.println("Color is called "+col);

    }
    private String col;

    public String getCol() {
        return col;

    }
}
public class Main {

    
color c;
    public static void main(String[] args) {
     Main m = new Main();

     m.c=color.GREEN;
    }
}

Output-
Color is called RRR
Color is called YYY
Color is called GGG

but i expect that only Green constructor should be invoked and output would be "Color is called GGG"

Moreover if i create an overloaded constructor with two parameters and if only that is invoked ,we get rest of the constructors called too.

Does it happen in case of enum unkile to class contructors?

[Tom Reilly]

Enums are classes. The compiler just treats them a little special. Their constructors are the same. The difference is in how the instances can be created. Class instances are created using the new operator by any other code that has access to the class (and a couple other ways that are not relevant to this conversation). The compiler prevents you from using the new operator on enums (it adds protection even greater than defining a constructor as private).

The compiler (under the covers) defines and initialises one static final reference for each enum element that you define. For example, you defined an enum called Color and defined the Color elements RED, WHITE, and BLUE (well, I changed the colors for the good ol' USA). Then only three static final references are defined and initialized by the compiler. So enum instances are created the same as any other object that must be assigned to a static reference - before any code uses the class (or enum).

As an illustration of enums being classes, I modified your code as follows. As you mentioned, there can be multiple constructors. One constructor can even call the other one. An enum can override methods and can even have a main() method. To show when enum instances are created I modified the printlns to illustrate.

public enum Color
{
    RED("Red"), WHITE("White"), BLUE("Blue", true);
    
    String color;
    boolean favorite;
    
    private Color(String color)
    {
        System.out.println("this.color = " + color);
        this.color = color;
    }
    
    private Color(String color, boolean favorite)
    {
        this(color);
        System.out.println("this.favorite = " + favorite);
        this.favorite = favorite;
    }
    
    @Override
    public String toString()
    {
        return this.color;
    }
    
    public static void main(String...args)
    {
        Color red = Color.RED;
        System.out.println("COLOR.RED is " + red);
        
        // The compiler complains about this code.
        //Color newColor = new Color("GREEN");
    }
}

import java.io.File;

public class ColorTest
{
    public static void main(String...args)
    {
        try {
            System.out.println("ColorTest.main() start");
            File file = new File("somefile.txt");
            if (file.exists())
                System.out.println("somefile.txt exists");
            else
                System.out.println("somefile.txt does not exist");
            
            
            System.out.println("First reference to Color is next");
            Color red = Color.RED;
            System.out.println("COLOR.RED is " + red);
            
            // The compiler complains about this code.
            //Color newColor = new Color("GREEN");

        } finally {
            System.out.println("ColorTest.main() end");
        }
    }
}

BTW, the static final instances are also the reason why you can use the == operator to compare two enum references.

Also BTW, I started to answer your question and then got carried away. I hope I did not add confusion.

[Deepak Bobal]

Thank you Tom.

output of your program is -

First reference to Color is next
this.color = Red
this.color = White
this.color = Blue
this.favorite = true
COLOR.RED is Red

So do i consider that all the constructors of enum are invoked with a single call of an enum.

As at line 17 we call only RED but WHITE is called automatically.

[Ikpefua Jacob-Obinyan]

Deepak Bobal wrote:

enum color {

    RED("RRR"), YELLOW("YYY"), GREEN("GGG");

    color(String col) {
        this.col = col;
        System.out.println("Color is called "+col);

    }
    private String col;

    public String getCol() {
        return col;

    }
}
public class Main {

    
color c;
    public static void main(String[] args) {
     Main m = new Main();

     m.c=color.GREEN;
    }
}

Output-
Color is called RRR
Color is called YYY
Color is called GGG

but i expect that only Green constructor should be invoked and output would be "Color is called GGG"

Moreover if i create an overloaded constructor with two parameters and if only that is invoked ,we get rest of the constructors called too.

Does it happen in case of enum unkile to class contructors?

Hello Deepak I was precisely studying enums yesterday, you know enum constructors are automatically INVOKED.
Modify your code like this and the out-put will be GGG:

enum color {  
	     RED("RRR"), YELLOW("YYY"), GREEN("GGG");  
	     color(String col) {  
	         this.col = col; 
	    }  
	    private String col;  
	   
	     public String getCol() {  
	         return col;  
	  
	    }  
	 }  
public class Main {
	 color c;
	public static void main(String[] args){
		Main m = new Main();
	System.out.println(m.c.GREEN.getCol());
	}
}