编程知识 cdmana.com

This article quickly grasps the usage of Java enumeration

One 、 enumeration

In mathematics and computer science theory , Of a dataset enumeration   Is a program that lists all members of a finite sequence set , Or the count of a particular type of object . enumeration , It's a collection of enumerable finite objects .

JDK1.5 Before , Need custom enumeration class ;

JDK1.5 after , have access to enum Keyword definition enumeration class , It's super simple ;

JDK1.6 after ,switch Enumeration statements support , Make the code more concise and robust ;

If the enumeration class has only one member , It can be used as a single instance mode , in other words , The singleton pattern can be seen as a special case of enumeration ;

1. Application scenarios

It can be applied to all scenarios where a finite number of values can be defined , Often used to set as a constant , such as :

  1. There are four seasons in a year , Define the name of the four seasons ;
  2. In a year 12 Months , Defines the name of the month ;
  3. All colors have 3 Of primary colors , Can define 3 Primary colors ;

2. Typical applications

The state of a thread is implemented using enumeration classes ,java.lang.Thread.State, You can see that it defines the various states of the thread .

@Test
 public void testTheadState(){
     // Get enumeration object , And loop out 
     Thread.State[] states = Thread.State.values();
     for(Thread.State s : states){
         System.out.println(s);
     }
 }

Running results :

 NEW
 RUNNABLE
 BLOCKED
 WAITING
 TIMED_WAITING
 TERMINATED

Two 、 Code implementation

1. Custom enumeration class

/**
  *  Custom implemented enumeration class —— season 
  *  An enumeration is a collection of a finite number of objects that can be enumerated , There are only four seasons in a year , All can be listed , So it is suitable to use enumeration form 
  *  The way to write a custom enumeration class is similar to the singleton pattern , Or we can say , The singleton pattern is a special case of enumerating a class with only one object .
  *
  *  The key points of the custom enumeration class are as follows :
  * 1.  The constructor of an enumeration class must be privatized , External calls are not allowed , Prevent external changes to enumerated objects ;
  * 2.  The properties of an enumeration class must be defined as private final, Avoid external modifications ;
  * 3.  Enumeration classes need to create their own enumeration objects , Enumeration objects must be defined as public static final, External access is provided .
  *
  * @author hello
  * @date 2020/11/06
  */
 public class CustomSeasonEnum {
     /**
      *  Property is defined as private final, Avoid being externally modified 
      */
     private final String seasonName;
     private final String seasonDesc;
 
     /**
      *  The constructor is privatized , You can specify the parameters of the constructor , It is convenient to assign values when instantiating 
      */
     private CustomSeasonEnum(String seasonName, String seasonDesc){
         this.seasonName = seasonName;
         this.seasonDesc = seasonDesc;
     }
 
     public String getSeasonName() {
         return seasonName;
     }
 
     public String getSeasonDesc() {
         return seasonDesc;
     }
 
     /**
      *  Define enumeration objects , The most important thing 
      */
     public static final CustomSeasonEnum SPRING = 
         new CustomSeasonEnum("Spring"," The spring breeze blows on my face ");
     public static final CustomSeasonEnum SUMMER = 
         new CustomSeasonEnum("Summer"," Life is like summer flowers ");
     public static final CustomSeasonEnum AUTUMN = 
         new CustomSeasonEnum("Autumn"," The autumn wind blows ");
     public static final CustomSeasonEnum WINTER = 
         new CustomSeasonEnum("Winter"," It's warm in winter ");
 }

Write test cases as follows :

public class CustomSeasonEnumTest {
     @Test
     public void testCustomEnum(){
         CustomSeasonEnum season = CustomSeasonEnum.SPRING;
         System.out.println(season.getSeasonName() + " : " + season.getSeasonDesc());
     }
 }

Running results : You can see , The call is correct

 Spring :  The spring breeze blows on my face 

2. Use enum Keyword definition enumeration class

2.1 Use enum Defined enumeration class

Use enum Defined enumeration class , It's just a simplified form of custom enumeration class , It can also contain custom attributes 、 Method 、 Construction method, etc , Compared with the custom enumeration class , Simplify the declaration of enumeration objects , omitted public static final And new Object and so on , The definition of enumeration objects is thread safe , So you can also use enumeration to define singleton patterns .

Compared with the custom enumeration class , Use enum Enumeration class has the following characteristics :

  1. Enumeration objects must be placed first , That is to say, you must sign other custom properties or methods ;
  2. Ignored public static final And new Object and so on ;
/**
  *  Use enum Keyword defined enumeration values 
  */
 public enum SeasonEnum {
     /**
      *  Throughout the year , In turn : spring 、 summer 、 autumn 、 winter 
      *  Compared with custom enumeration :
      * 1.  It has to be on the front , That is to say, you must sign other custom properties or methods ;
      * 2.  Ignored public static final  And  new  Object and so on ;
      */
     SPRING("Spring"," The spring breeze blows on my face "),
     SUMMER("Summer"," Life is like summer flowers "),
     AUTUMN("Autumn"," autumn "),
     WINTER("Winter"," It's warm in winter ");
     /**
      *  Enumerate the properties of a class 
      */
     private final String seasonName;
     private final String seasonDesc;
 
     /**
      *  The constructor is privatized 
      */
     private SeasonEnum(String seasonName, String seasonDesc){
         this.seasonName = seasonName;
         this.seasonDesc = seasonDesc;
     }
 
     /**
      *  Public methods for getting properties 
      */
     public String getSeasonName() {
         return seasonName;
     }
 
     public String getSeasonDesc() {
         return seasonDesc;
     }
 }

2.2 The simplest example of enumerating classes

The simplest form of enumeration is to enumerate only objects , No attributes , And it doesn't declare constructors , There's no way to define it .

// The simplest example of enumeration 
 public enum ColorEnum {
     RED,GREEN,BLUE;
 }
 
 // The test case 
 @Test
 public void testColorEnum(){
     // Get red 
     ColorEnum red = ColorEnum.RED;
     System.out.println(red);
     System.out.println("------");
     // Get all objects 
     ColorEnum[] colors = ColorEnum.values();
     for (ColorEnum colorEnum : colors){
         System.out.println(colorEnum);
     }
 }

Running results :

 RED
 ------
 RED
 GREEN
 BLUE

2.3 Common methods

2.3.1 values()

 

Method function : Get all the enumerated object arrays , You can traverse through , And make a judgment accordingly ;

Method example :

@Test
 public void testValues(){
     ColorEnum[] colorEnums = ColorEnum.values();
     for(ColorEnum colorEnum : colorEnums){
         System.out.println(colorEnum);
     }
 }
 // Running results :
 RED
 GREEN
 BLUE

2.3.2 valueOf(String name)

Method function : Get an enumeration object with the same name from a string ;

matters needing attention :

  1. The string name passed in must be the name of the enumeration object , You can't type ;
  2. If the string input is wrong , It's not going back null, It's a program error ;

Method example :

(1) The correct sample : Get the enumeration object with the corresponding name

 @Test
 public void testValueOf(){
     String colorName = "RED";
     ColorEnum colorEnum = ColorEnum.valueOf(colorName);
     System.out.println(colorEnum);
 }
 // Running results :
 RED

(2) The wrong sample : Throw an exception IllegalArgumentException

@Test
 public void testValueOfError(){
     String colorName = "REEEEED";
     ColorEnum colorEnum = ColorEnum.valueOf(colorName);
     System.out.println(colorEnum);
 }
 // Running results : Throw an exception IllegalArgumentException
 java.lang.IllegalArgumentException: No enum constant com.tengol.demo.javase.basic.enums.ColorEnum.REEEEED
     at java.lang.Enum.valueOf(Enum.java:238)
     at com.tengol.demo.javase.basic.enums.ColorEnum.valueOf(ColorEnum.java:3)

2.4 Enumeration class implements the interface

Use enum Keyword defined enumeration classes are inherited from abstract classes java.lang.Enum, because Java Multiple inheritance is not supported , So enumeration classes can't inherit other classes , But you can implement one or more interfaces .

Enumeration class can implement interface , At the same time, enumerating objects can also override the abstract methods of the implemented interfaces , By decompiling, you can see , When enumerating objects and rewriting interface methods, it is implemented by anonymous inner class .

First step : Defining interfaces

/**
  *  Interface : Print information 
  */
 public interface Info {
     public void print();
 }

The second step : Enumerate classes to implement interface methods , Enumerating objects can override methods

public enum WeekEnum implements Info {
     /**
      *  Seven days a week 
      */
     MONDAY{
         @Override
         public void print() {
             super.print();
         }
     },
     TUESDAY{
         @Override
         public void print() {
             System.out.println("Tuesday...");
         }
     },
     WEDNESDAY,
     THURSDAY,
     FRIDAY,
     SATURDAY,
     SUNDAY;
 
     public void print() {
         System.out.println("WeekEnum...");
     }
 }

The test case :

@Test
 public void testImpl(){
     // Tuesday rewritten print() Method , The method of executing the rewrite 
     WeekEnum tue = WeekEnum.TUESDAY;
     tue.print();
     // Not rewritten on Wednesday , perform WeekEnum Of print() Method 
     WeekEnum wed = WeekEnum.WEDNESDAY;
     wed.print();
 }

Running results :

Tuesday...
WeekEnum...

Some of the notes are from a training video from Silicon Valley , If you are interested in , Please pay attention to .

版权声明
本文为[Fishing alone]所创,转载请带上原文链接,感谢

Scroll to Top