Singleton Pattern - Doubt with Enum Singleton.

[Pankaj Shet]

Hi Ranchers,

It is said that Enum singletons are the best way way to create singletons.

How ever I have one doubt.

Writing Enum Singleton is very simple.

Eg.

public Enum SingletonInstance{
  INSTANCE;
  public void doStuff(){
     // blah blahh..
 }
}

and we access it in the following way,

SingletonInstance.INSTANCE.doStuff();


However,

If we write two or more Enum Constants like:

public Enum SingletonInstance{
  INSTANCE1, INSTANCE2, INSTANCE3;
  public void doStuff(){
     // blah blahh..
 }
}

doStuff() is accessible by all 3 INSTANCEs?

there are 2 possibilities:

1) 3 different Instances are created
2) Still at any point of time, irrespective of number of constants, only single instance is created?

If the 2nd possibility is true, then its a true singleton.

but if 1st possibility is true, Its like we are creating just one instance of the ENUM and saying its a singleton.

There should be a way to restrict the no of constants in the ENUM, to one and only one and not more than one to make the ENUM a Singleton.

I request your opinion on the same.

Regards,
-Pankaj.

[Junilu Lacar]

You are mixing concepts.

The enum singleton is only a singleton if you define one enum value. If you define more than one value, then you have as many instances as you have values. In your case there would be three instances of the enum class. By definition, you no longer have a singleton at that point.

Enums were not explicitly meant to allow the creation of singletons. Someone just noticed that the way enums work would make them a better and perhaps cleaner way to essentially define a Singleton.

[Pankaj Shet]

Thanks a Lot for your reply Junilu,

But if there are three instances getting created, if there are three constants, than that's not the singleton.  There must be the way to restrict enums to create a single instance irrespective of number of ENUM Constants.

Otherwise I can definately create the singleton object using class by creating just a single object of that class in the same way I create the single ENUM constant, without writing any additional code of restricting that class?

What's your say?

[Junilu Lacar]

Again, enums were not introduced into the language so that we could create singletons. It just so happens that the way enums work, it makes it a convenient mechanism for creating a singleton.

Your assertion that there should be a way to limit the number of enum values is like saying that because you can turn a car into a bed, there should be a way to register a bed so you can drive it on the highway.

Enums are primarily meant to define a finite set of constant values so that there is stricter type checking. Just because a single enum value can be used to represent a singleton doesn't mean the language should provide a means to limit the number of values defined. That is solely a design decision that is in the purview of the designer/programmer. If you don't want more than one value in your enum type, then just don't define more than one. It's that simple.

[Junilu Lacar]

You can find out more about the real motivation for introducing enums to Java by searching for "java typesafe enum pattern" -- As you'll see, the motivation is primarily about type safety and not about creating Singleton objects.

[Pankaj Shet]

Thanks a lot for your response.

[Laurent de Laprade]

Enum with 3 constants would be 3 singletons ?
Convenient for descriptive data which should have only one instantiation throughout a program.
I personally use it  for application menu description.
I can then have several engines to parse the menu structures and render it in different ways

Example:

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ______                              _____ _             _            _                            _   _
//|  ____|                            / ____(_)           | |          | |                          | | | |
//| |__   _ __  _   _ _ __ ___  ___  | (___  _ _ __   __ _| | ___ _ __ | |_ ___  _ __    _ __   __ _| |_| |_ ___ _ __ _ __
//|  __| | '_ \| | | | '_ ` _ \/ __|  \___ \| | '_ \ / _` | |/ _ \ '_ \| __/ _ \| '_ \  | '_ \ / _` | __| __/ _ \ '__| '_ \
//| |____| | | | |_| | | | | | \__ \  ____) | | | | | (_| | |  __/ | | | || (_) | | | | | |_) | (_| | |_| ||  __/ |  | | | |
//|______|_| |_|\__,_|_| |_| |_|___/ |_____/|_|_| |_|\__, |_|\___|_| |_|\__\___/|_| |_| | .__/ \__,_|\__|\__\___|_|  |_| |_|
//                                                    __/ |                             | |
//                                                   |___/                              |_|
// With the Java extended and powerful desin of enums,
// Java Enums become 'THE' way to implement the singleton pattern.
// Note: Jave enums rich features does not exist in C neither in C++, nor in C#
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//enums:
//- JETMenuGroup for grouping menu items by categories
//- JETMenuItem with all required details for creating each UI menu item
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class JetMenuConfiguration
{
    public enum JETMenuGroup
    {
        //----------------------------------------------------------------------------------------------------------------------------------------------|
        //-MENU GROUP ENUM ID-||---MENU GROUP LABEL-------||---ICON-----------||---OVERRIDES RIGHTS REQUIREMENTS----------------------------------------|
        //----------------------------------------------------------------------------------------------------------------------------------------------|
        MENU_ADMINISTRATION    ("Administrative tasks",    "adminTasks.png"    ) {@Override public boolean requireAdminRights() { return true; }}      ,
        MENU_OPERATIONS        ("Operator tasks"      ,    "operatorTasks.png" ) {@Override public boolean requireOperatorRights() { return true; }}   ,
        MENU_USER              ("User operations"     ,    "userOperations.png")                                                                       ,
        MENU_DASHBOARD         ("Dashboards"          ,    "dashboard.png"     )                                                                       ,
        MENU_SUPERUSER         ("Super User tasks"    ,    "superUserTasks.png") {@Override public boolean requireSuperUserRights() { return true; }}  ,
        MENU_SETTINGS          ("Settings"            ,    "themes.png"        )                                                                       ,
        MENU_MISC              ("Start"               ,    "start.png"         )                                                                       ,
        MENU_DUMMY             ("Dummy"               ,    ""                  )                                                                       ;

        private final String label;
        private final String icon;
        public String getLabel(){ return label; }
        public String getIcon(){ return getResourceRoot() + icon; }
        public String getIcon26(){ return getIcon() + "26.png"; }
        private String getResourceRoot() { return "img/jetMenu/"; }

        private JETMenuGroup(String label, String icon){ this.label = label; this.icon = icon; }

        public boolean requireSuperUserRights() { return false; }
        public boolean requireAdminRights()     { return false; }
        public boolean requireSuperManRights()  { return false; }
        public boolean requireOperatorRights()  { return false; }
    }

    public enum JETMenuItem
    {
        //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
        //---MENU ENUM ID-------------||---MENU GROUP--------------------||---MENU LABEL-------||---ICON-------------------||---DESCRIPTION--------------------------------------------------------------------------------------||---ACTIVABLE MODULE-----|
        //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
        JET_CMD_ADMIN_DEV_HANDLING     (JETMenuGroup.MENU_ADMINISTRATION, "dev handling"        , "device_manager26.png"    , "device handling, based on ESL CI status"                                                           , "DeviceHandling"        ),
        JET_CMD_SERVICES_CONFIGURATION (JETMenuGroup.MENU_ADMINISTRATION,"services configurations",
...
...

        JET_CMD_RESTART                (JETMenuGroup.MENU_MISC,           "Restart Application" , "led-square-grey-25.png"  , "Try restarting the application if connection is lost or application not responsive"                , "DefaultActivity"       ),
        JET_CMD_DUMMY                  (JETMenuGroup.MENU_DUMMY,          "Not used"            , ""                        , ""                                                                                                  , "not used"              );


        private final JETMenuGroup group;
        private final String label;
        private final String icon;
        private final String description;
        private final String activity; // a way to disable items based on activity name
        public JETMenuGroup getGroup(){ return group; }
        public String getLabel(){ return label; }
        public String getDescription(){ return description; }
        public String getActivity(){ return activity; }
        public String getIcon(){ return getResourceRoot() + icon; }
        private String getResourceRoot() { return "img/jetMenu/commands/"; }

        private JETMenuItem(JETMenuGroup grp, String lbl, String ico, String desc, String act)
            { group=grp; label=lbl; icon=ico; description=desc; activity=act; }

        public static JETMenuItem getMenuItemFromString(String value)
        {
            try{ return JETMenuItem.valueOf(value); }
            catch(Exception e){ return JET_CMD_DUMMY; }
        }

        public boolean requireSuperUserRights() { return getGroup().requireSuperUserRights(); }
        public boolean requireAdminRights()     { return getGroup().requireAdminRights(); }
        public boolean requireSuperManRights()  { return getGroup().requireSuperManRights(); }
        public boolean requireOperatorRights()  { return getGroup().requireOperatorRights(); }

        // for classifying related commands inside a menu subfolder
        public String menuFolder()  { return null; }

    }
}

I use it as well for database table columns description,
then have an SQL engine code generator which can parse those enums and create various SQL queries

[Campbell Ritchie]

Welcome to the Ranch

Laurent de Laprade wrote:Enum with 3 constants would be 3 singletons ? . . .

I think that a class with exactly three instances is a variation of a Singleton. But, as stated previously, a singleton is not necessarily a good thing. Many people think it is a bad thing. I don't think the enum pattern was designed for what you are doing, even though you seem to have got it to work. You ould probably do the same with multiple text files containing the parts of the SQL code to interpose into the constant parts.