Enumerations and Nested Classes

This study material provides a comprehensive overview of enumerations and nested classes in Java, focusing on their definitions, uses, and various examples to illustrate concepts effectively.

Enumerations

An enumeration (often abbreviated as enum) is a special data type in Java that contains a fixed set of constants. Enums are particularly useful when the possible values of a variable are known and limited. This allows for enhanced type safety as invalid values cannot be introduced without causing a compile-time error. Enums can be declared independently or as part of a class.

Some common examples of when to use enums include:

Compass directions (NORTH, SOUTH, EAST, WEST)
Months of the year (JANUARY, FEBRUARY, ...)
Card values in a deck (ACE, TWO, ..., KING)

Creating an Enum

To create an enum, use the enum keyword followed by an identifier and a set of values (known as enum constants). For instance:

public enum Period { PRELIM, MIDTERM, PREFINAL, FINAL; }

After declaring an enum type, variables of that type can be created:

Period p;

Then, an enum constant can be assigned to this variable:

p = Period.MIDTERM;

Enum Class Characteristics

An enum type in Java behaves similarly to a class. The constants defined within an enum are instances of that class, and they have access to various built-in methods. Here are some key methods:

Method	Description	Example
`toString()`	Returns the name of the calling constant object.	`p.toString()` returns "MIDTERM"
`ordinal()`	Returns the position of the constant within the list (0-based).	`p.ordinal()` returns 1
`equals()`	Checks if the argument is the same as the calling object.	`p.equals(Period.PRELIM)` returns false
`compareTo()`	Compares ordinal values of two enum constants.	`p.compareTo(Period.FINAL)` returns negative.

Static Methods in Enums

Comparison operators can be employed with enum constants for convenience, but Java also provides some useful static methods:

valueOf(String name): Accepts a string and returns the corresponding enum constant.
values(): Returns an array of all the constants defined in the enum.

Example of Using Enums

The following program illustrates how to utilize enums with user input:

import java.util.Scanner; public class EnumDemo { enum Period {PRELIM, MIDTERM, PREFINAL, FINAL}; public static void main(String[] args) { Period pd; String input; Scanner sc = new Scanner(System.in); System.out.println("The grading periods are:"); for(Period p : Period.values()) System.out.print(p + " "); System.out.print("\nSelect a grading period: "); input = sc.nextLine().toUpperCase(); pd = Period.valueOf(input); System.out.println("You entered " + pd); int position = pd.ordinal(); System.out.println(pd + " is in position " + position); System.out.println("So its period number is " + (position + 1)); }}

This will prompt users to select a grading period, convert their input, and display their chosen enum value along with its corresponding position.

Using Enums in Switch Structures

Enums can also be effectively utilized within switch statements. For instance, the following example shows a class that uses an enum to define pizza sizes and display corresponding prices:

public class EnumDemo2 { enum Size {REGULAR, LARGE, PARTY}; public static void main(String[] args) { Size s = Size.LARGE; System.out.print("Price of pizza is "); switch(s) { case REGULAR: System.out.println("381.00"); break; case LARGE: System.out.println("602.00"); break; case PARTY: System.out.println("799.00"); break; } }}

By using enums, the program ensures type safety and enhances code maintainability.

Nested Classes

In Java, a nested class is a class defined within another class, enhancing coherence in the organization of related classes. There are four main types of nested classes:

Static member class: Can access all static methods of the outer class.
Non-static member class (inner class): Requires an instance of the outer class and can access all its fields and methods.
Local class: Defined within the body of a method.
Anonymous class: A local class without a name.

The common purpose for nesting a class is when the inner class is intended for use by the outer class only. This encapsulation improves readability and maintainability in code.

Example of Nested Classes

The following example depicts a real estate listing class with a nested class for house data:

public class RealEstateListing { private int listingNumber; private double price; private HouseData hData; public RealEstateListing(int num, double price, String address, int sqFt) { listingNumber = num; this.price = price; hData = new HouseData(address, sqFt); } public void display() { System.out.println("Listing number #" + listingNumber + " Selling for Php" + price); System.out.println("Address: " + hData.streetAddress); System.out.println(hData.squareFeet + " square feet"); } private class HouseData { private String streetAddress; private int squareFeet; public HouseData(String address, int sqFt) { streetAddress = address; squareFeet = sqFt; } }}

In this program, the inner class HouseData is made private, ensuring its members aren't accessible outside the RealEstateListing class. Furthermore, inner classes can access private fields and methods of their enclosing classes, but the opposite is not true unless they are made public. If the intent is to use a designated class beyond its outer class, it should not be nested.

Conclusion

Understanding enumerations and nested classes is vital for developing robust Java applications. Both concepts enhance type safety and encapsulation, allowing developers to write clear and maintainable code.

References

Farrell, J. (2019). Java programming. Cengage Learning, Inc.
Oracle Academy (n.d.). Citing sources. Retrieved from https://academy.oracle.com/
Oracle Docs (n.d.). Citing sources. Retrieved from https://docs.oracle.com/javase/tutorial/java/javaOO/index.html

Overview of Enumerations and Nested Classes in Java

Overview of Enumerations and Nested Classes in Java