Enums and Inner Classes
This lesson covers enums and inner classes—special types of classes in Java.
Enums
Enums are used to define a fixed set of constants.
Defining an Enum
JAVA
public enum Season {
SPRING, SUMMER, AUTUMN, WINTER
}
Using Enums
JAVA
public class EnumDemo {
public static void main(String[] args) {
Season season = Season.SPRING;
switch (season) {
case SPRING:
System.out.println("Spring");
break;
case SUMMER:
System.out.println("Summer");
break;
case AUTUMN:
System.out.println("Autumn");
break;
case WINTER:
System.out.println("Winter");
break;
}
}
}
Enum Attributes and Methods
JAVA
public enum Season {
SPRING("Spring", 1),
SUMMER("Summer", 2),
AUTUMN("Autumn", 3),
WINTER("Winter", 4);
private String name;
private int order;
// Constructor
Season(String name, int order) {
this.name = name;
this.order = order;
}
// Getters
public String getName() {
return name;
}
public int getOrder() {
return order;
}
}
Common Enum Methods
| Method | Description | Example |
|---|---|---|
values() |
All enum values | Season.values() |
valueOf() |
String to enum | Season.valueOf("SPRING") |
ordinal() |
Enum index | Season.SPRING.ordinal() → 0 |
name() |
Enum name | Season.SPRING.name() → "SPRING" |
Example: Enum Methods
JAVA
public class EnumMethodDemo {
public static void main(String[] args) {
// Iterate all enum values
for (Season s : Season.values()) {
System.out.println(s.ordinal() + ": " + s.getName());
}
// String to enum
Season spring = Season.valueOf("SPRING");
System.out.println(spring.getName()); // Spring
// Compare enums
System.out.println(Season.SPRING == Season.SPRING); // true
System.out.println(Season.SPRING.equals(Season.SPRING)); // true
}
}
Example: Weekday Enum
JAVA
public enum Weekday {
MONDAY("Monday", true),
TUESDAY("Tuesday", true),
WEDNESDAY("Wednesday", true),
THURSDAY("Thursday", true),
FRIDAY("Friday", true),
SATURDAY("Saturday", false),
SUNDAY("Sunday", false);
private String name;
private boolean isWorkday;
Weekday(String name, boolean isWorkday) {
this.name = name;
this.isWorkday = isWorkday;
}
public String getName() {
return name;
}
public boolean isWorkday() {
return isWorkday;
}
}
public class WeekdayDemo {
public static void main(String[] args) {
for (Weekday day : Weekday.values()) {
String type = day.isWorkday() ? "Weekday" : "Weekend";
System.out.println(day.getName() + " - " + type);
}
}
}
Inner Classes
Inner classes are defined inside another class.
Member Inner Class
JAVA
public class Outer {
private int x = 10;
// Member inner class
public class Inner {
public void show() {
// Can access outer class's private members
System.out.println("x = " + x);
}
}
public void test() {
Inner inner = new Inner();
inner.show();
}
}
public class InnerClassDemo {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.show(); // x = 10
}
}
Static Inner Class
JAVA
public class Outer {
private static int x = 10;
private int y = 20;
// Static inner class
public static class StaticInner {
public void show() {
// Can only access outer class's static members
System.out.println("x = " + x);
// System.out.println("y = " + y); // Compile error!
}
}
}
public class StaticInnerDemo {
public static void main(String[] args) {
// No need to create outer class object
Outer.StaticInner inner = new Outer.StaticInner();
inner.show(); // x = 10
}
}
Local Inner Class
JAVA
public class Outer {
public void method() {
// Local inner class: defined in a method
class LocalInner {
public void show() {
System.out.println("Local inner class");
}
}
LocalInner inner = new LocalInner();
inner.show();
}
}
Anonymous Inner Class
JAVA
public interface Greeting {
void greet(String name);
}
public class AnonymousDemo {
public static void main(String[] args) {
// Anonymous inner class
Greeting hello = new Greeting() {
@Override
public void greet(String name) {
System.out.println("Hello, " + name + "!");
}
};
hello.greet("Alice"); // Hello, Alice!
// Lambda shorthand (functional interface)
Greeting hi = name -> System.out.println("Hi, " + name + "!");
hi.greet("Bob"); // Hi, Bob!
}
}
Example: Anonymous Inner Class for Event Handling
JAVA
public interface OnClickListener {
void onClick(String button);
}
public class Button {
private String text;
private OnClickListener listener;
public Button(String text) {
this.text = text;
}
public void setOnClickListener(OnClickListener listener) {
this.listener = listener;
}
public void click() {
if (listener != null) {
listener.onClick(text);
}
}
}
public class ButtonDemo {
public static void main(String[] args) {
Button btn = new Button("Submit");
// Anonymous inner class
btn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(String button) {
System.out.println(button + " was clicked");
}
});
btn.click(); // Submit was clicked
}
}
Inner Class Comparison
| Type | Location | Access Outer Class | Creation |
|---|---|---|---|
| Member inner class | Inside class | All members | outer.new Inner() |
| Static inner class | Inside class | Static members | new Outer.Inner() |
| Local inner class | Inside method | All members + local final | Create inside method |
| Anonymous inner class | Anywhere | Same as local | new Interface(){} |
❓ Frequently Asked Questions
Q When should I use enums?
A When defining a fixed set of constants, like seasons, weekdays, or states.
Q When should I use anonymous inner classes?
A For simple interface implementations, especially event callbacks. Java 8+ recommends Lambda for functional interfaces.
Q What are inner classes used for?
A Implementing callbacks, accessing outer class private members, organizing related classes.
📖 Summary
- Enums define fixed constants and can have attributes and methods
- Inner classes are categorized as: member, static, local, anonymous
- Anonymous inner classes can be shortened to Lambda (for functional interfaces)
- Common enum methods: values, valueOf, ordinal
📝 Exercises
- Season enum: Define a Season enum with season name and temperature range
- State machine: Implement order states using enums (Pending, Paid, Shipped, Completed)
- Anonymous inner class: Use anonymous inner class to implement Comparator sorting
Next Lesson
In the next lesson, we'll learn about Exception Handling — how to handle errors in programs.