What is the difference between Java enumeration types and interfaces?

The enumeration type is a collection of fixed values ​​and cannot be inherited, but member methods and variables can be defined. The interface defines a set of methods and constants, which cannot be instantiated, but can be implemented by the class. The methods of the interface can only be declared but cannot be implemented, but constants can be defined.

The difference between Java enumeration types and interfaces

In Java, enumeration types and interfaces are both very useful language features, but there is a difference between them There is a clear difference.

Enumeration type

• The enumeration type is a special data type used to represent a limited and fixed set of values.
• Each value of an enumeration type is called an enumeration constant.
• Enumeration types are final and cannot be inherited.

Interface

• An interface is a reference type that defines a set of methods and constants.
• Interfaces cannot be instantiated and can only be implemented by classes.
• The methods in the interface are not implemented, only declared.

Table 1: The difference between enumerated types and interfaces

Features	Enumerated types	Interface
Value type	Fixed and limited	Variable, can be added as needed
Inheritance	Cannot be inherited	Can be implemented by multiple classes
Member methods	Can be defined	Can only be declared, not implemented
Member variables	Can define constants	Can define constants and Method
Instantiation	cannot be instantiated	cannot be instantiated

## Practical case

Enumeration type example

public enum DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Interface example

public interface Shape {
    double getArea();
    double getPerimeter();
}

Enumeration type and interface example

public enum ShapeType implements Shape {
    CIRCLE {
        @Override
        public double getArea() {
            return Math.PI * radius * radius;
        }

        @Override
        public double getPerimeter() {
            return 2 * Math.PI * radius;
        }
    },

    RECTANGLE {
        @Override
        public double getArea() {
            return length * width;
        }

        @Override
        public double getPerimeter() {
            return 2 * (length + width);
        }
    }
}

In this example, the

ShapeType enumeration type implements the Shape interface. CIRCLE and RECTANGLE are enumeration constants, which represent circles and rectangles respectively. These enumeration constants implement methods of the Shape interface, providing specific behavior for circles and rectangles.

The above is the detailed content of What is the difference between Java enumeration types and interfaces?. For more information, please follow other related articles on the PHP Chinese website!