What are enumerations? 

Enumerations (or enums) are special Java types which allows limited list of values. These values can be passed to control statements (ex. switch(), if())
In prior releases, the standard way to represent an enumerated type was the int Enum pattern: // int Enum Pattern - has severe problems!public static final int SEASON_WINTER = 0;public static final int SEASON_SPRING = 1;public static final int SEASON_SUMMER = 2;public static final int SEASON_FALL = 3;
This pattern has many problems, such as:
• Not typesafe - Since a season is just an int you can pass in any other int value where a season is required, or add two seasons together (which makes no sense). • No namespace - You must prefix constants of an int enum with a string (in this case SEASON_) to avoid collisions with other int enum types. • Brittleness - Because int enums are compile-time constants, they are compiled into clients that use them. If a new constant is added between two existing constants or the order is changed, clients must be recompiled. If they are not, they will still run, but their behavior will be undefined.
• Printed values are uninformative - Because they are just ints, if you print one out all you get is a number, which tells you nothing about what it represents, or even what type it is. It is possible to get around these problems by using the Typesafe Enum pattern (see Effective Java Item 21), but this pattern has its own problems: It is quite verbose, hence error prone, and its enum constants cannot be used in switch statements.
In 5.0, the Java™ programming language gets linguistic support for enumerated types. In their simplest form, these enums look just like their C, C++, and C# counterparts: enum Season { WINTER, SPRING, SUMMER, FALL }
But appearances can be deceiving. Java programming language enums are far more powerful than their counterparts in other languages, which are little more than glorified integers. The new enum declaration defines a full-fledged class (dubbed an enum type). In addition to solving all the problems mentioned above, it allows you to add arbitrary methods and fields to an enum type, to implement arbitrary interfaces, and more. Enum types provide high-quality implementations of all the Object methods. They are Comparable and Serializable, and the serial form is designed to withstand arbitrary changes in the enum type.

Answered by Nishu%27s at 11:58 PM on November 03, 2008

An enumeration is a type that can hold a set of constant values that are defined by the user. Once you define an enumeration you can use it like integer types. Enumerations are good for collecting named values in groups. If you have a set of values that keep recurring, consider making them into an enum. You will have to deal with the restriction that constant names have to be identifiers, but if that is doable, then enumerations can be very useful.

For E.g. enum {OFF, ON};

The enum defines two integer constants called enumerators and these constants are assigned values by default. The value assigned to OFF = 0 and ON = 1. The above is an unnamed enumeration, however an enum can be named.

For E.g. enum STATE {OFF, ON};

Each enumeration is a distinct type and the type of the enumeration is the enumerator. For example OFF is of type STATE.

An enumerator can optionally be initialized by a constant expression of integral type.
E.g. enum {WHITE = 3, BLACK = 5};

A value of an integral type can be converter to an enumeration type. This needs to be done explicitly. The results are undefined unless the value is within the range of the enumeration.

E.g. enum COLORS {RED = 1; BLUE = 3, WHITE = 7};
COLORS c1 = COLORS (5);

All enumerators are converted to integral type for any arithmetic operation.

With reference to: http://snipr.com/4z3o1

Answered by Karthick AR at 7:58 PM on November 03, 2008

An enumeration consists of a set of named integer constants. An enumeration type declaration gives the name of the (optional) enumeration tag and defines the set of named integer identifiers (called the "enumeration set," "enumerator constants," "enumerators," or "members"). A variable with enumeration type stores one of the values of the enumeration set defined by that type.

Variables of enum type can be used in indexing expressions and as operands of all arithmetic and relational operators. Enumerations provide an alternative to the #define preprocessor directive with the advantages that the values can be generated for you and obey normal scoping rules.

In ANSI C, the expressions that define the value of an enumerator constant always have int type; thus, the storage associated with an enumeration variable is the storage required for a single int value. An enumeration constant or a value of enumerated type can be used anywhere the C language permits an integer expression.

Answered by NIVEDITA at 6:39 PM on November 03, 2008

An enumeration is a data type consisting of a set of named values that represent integral constants, known as enumeration constants. An enumeration also referred to as an enumerated type because you must list (enumerate) each of the values in creating a name for each of them. In addition to providing a way of defining and grouping sets of integral constants, enumerations are useful for variables that have a small number of possible values.

You can declare an enumeration type separately from the definition of variables of that type, as described in Enumeration type definition and Enumeration variable declarations; or you can define an enumeration data type and all variables that have that type in one statement, as described in Enumeration type and variable definitions in a single statement.


For JAVA ENUMERATION Refer below link
http://www.geekinterview .com/question_details/29490
e n.wikipedia.org/wiki/Enumerati ve

Answered by Sanjeev at 6:11 PM on November 03, 2008

well, An enumeration is a special type in the .NET Framework that is comprised of a number of named constants. While you might not have created an enumeration type yourself, you have likely used enumerations many times in day-to-day programming. For example, each item in an ASP.NET DataGrid has an ItemType property, which is of type ListItemType. ListItemType is an enumeration with values like Header, Item, AlternatingItem, Footer, and others. Too, if you've created files with the System.IO.File class you've used the FileMode and FileAccess enumerations; if you have worked with regular expressions, you've likely used the RegexOptions enumeration.

When creating your own classes and components, enumerations can be used to make your code strongly typed, which makes the code more readable and less prone to errors. Creating and using enumerations is simple, so there's no reason not to use enumerations where applicable. This article looks at how to create enumeration types, how enumerations differ from constants, how to create enumerations whose members can be combined via bit-wise operations, and how to enumerate the members of an enumeration.

Answered by Jai Sri Ram at 5:55 PM on November 03, 2008