Introduzione dettagliata dell'uso di enum in Java e codice di esempio

Utilizzo di Java enum

Metodo di utilizzo uno: costanti

Prima di JDK1.5, definivamo le costanti in questo modo: public static fianl.... Ora, con gli enum, possiamo raggruppare le costanti correlate in un tipo di enumerazione e gli enum offrono più metodi rispetto ai costanti.

public enum Color { 
 RED, GREEN, BLANK, YELLOW 
} 

Metodo di utilizzo due: switch

Le espressioni switch prima di JDK1.6 supportavano solo i tipi int, char e enum. L'uso degli enum può rendere il nostro codice più leggibile.

enum Signal {
    GREEN, YELLOW, RED
  }
  public class TrafficLight {
    Signal color = Signal.RED;
    public void change() {
      switch (color) {
      caso RED:
        color = Signal.GREEN;
        break;
      caso YELLOW:
        color = Signal.RED;
        break;
      caso GREEN:
        color = Signal.YELLOW;
        break;
      }
    }
  }

Metodo di utilizzo tre: aggiungere un nuovo metodo all'enumerazione

Se si desidera definire il proprio metodo, è necessario aggiungere un punto e virgola alla fine della sequenza dell'istanza enum. E Java richiede che gli esempi enum siano definiti prima.

public enum Color {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;
    // 构造函数
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }
    // Metodi normali
    public static String getName(int index) {
      for (Color c : Color.values()) {
        if (c.getIndex() == index) {
          return c.name;
        }
      }
      return null;
    }
    // Metodi get set
    public String getName() {
      return name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public int getIndex() {
      return index;
    }
    public void setIndex(int index) {
      this.index = index;
    }
  }

Utilizzo quattro: Override dei metodi dell'enumerazione

Di seguito è fornito un esempio di override del metodo toString().

public class Test {
  public enum Color {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;
    // 构造函数
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }
    // Override del metodo
    @Override
    public String toString() {
      return this.index + "_" + this.name;
    }
  }
  public static void main(String[] args) {
    System.out.println(Color.RED.toString());
  }
}

Utilizzo cinque: Implementare l'interfaccia

Tutti gli enumeri derivano dalla classe java.lang.Enum. Poiché Java non supporta la multiereditarietà, gli oggetti enum non possono ereditare altre classi.

public interface Behaviour {
    void print();
    String getInfo();
  }
  public enum Color implements Behaviour {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    // 成员变量
    private String name;
    private int index;
    // 构造函数
    private Color(String name, int index) {
      this.name = name;
      this.index = index;
    }
    // 方法接口
    @Override
    public String getInfo() {
      return this.name;
    }
    // 方法接口
    @Override
    public void print() {
      System.out.println(this.index + ":" + this.name);
    }
  }

Utilizzo sei: Utilizzo degli enum con l'interfaccia

public interface Cibo {
    enum Caffè implements Cibo {
      BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
    }
    enum Dessert implements Cibo {
      FRUIT, CAKE, GELATO
    }
  }

Utilizzo sette: Riguardo all'uso delle collection enum

java.util.EnumSet e java.util.EnumMap sono due collection enum. EnumSet garantisce che gli elementi della collection non siano ripetuti; EnumMap ha come key un tipo enum e come value può essere qualsiasi tipo. Per l'uso di queste due collection non entrerò nei dettagli, ma si può fare riferimento alla documentazione JDK.

Differenza tra enum e costanti

Primo: Metodo di definizione comune dei costanti

Di solito utilizziamo il codice definito con il metodo public final static, come segue, utilizzando 1 per rappresentare il semaforo rosso, 3 per rappresentare il semaforo verde e 2 per rappresentare il semaforo giallo.

public class Luce {
    /* Lampada rossa */
    public final static int ROSSO = 1;
    /* Lampada verde */
    public final static int VERDE = 3;
    /* Lampada gialla */
    public final static int GIALLO = 2;
  }

Secondo: Metodo di definizione dei costanti enum

Ecco un esempio di definizione semplice del tipo enum, sembra che non possiamo definire ogni valore enum. Ad esempio, il codice per definire i semafori rossi, verdi e gialli potrebbe essere il seguente:

public enum Luce {
    ROSSO, VERDE, GIALLO;
  }

Possiamo rappresentare solo i semafori rossi, verdi e gialli, ma non possiamo rappresentare i valori specifici. Non preoccuparti, poiché il tipo enum fornisce un costruttore, possiamo utilizzare il costruttore e sovrascrivere il metodo toString per realizzare questo. Prima di tutto, aggiungiamo un metodo costruttore al tipo enum Luce, quindi ogni valore enum viene passato come parametro al costruttore, e sovrascriviamo il metodo toString, nel quale restituiamo i parametri passati al costruttore. Il codice modificato è il seguente:

public enum Luce {
  // Utilizzando i parametri del costruttore
  ROSSO(1), VERDE(3), GIALLO(2);
  // Definizione di variabile privata
  private int nCode;
  // Costruttore, il tipo enum può essere privato
  private Light(int _nCode) {
    this.nCode = _nCode;
  }
  @Override
  public String toString() {
    return String.valueOf(this.nCode);
  }
}

Terzo: Esempio completo di codice

Ecco un esempio completo di codice per il tipo enum:

public class TestLuce {
  // 1. Definire il tipo enum
  public enum Luce {
    // Utilizzando i parametri del costruttore
    ROSSO(1), VERDE(3), GIALLO(2);
    // Definizione di variabile privata
    private int nCode;
    // Costruttore, il tipo enum può essere privato
    private Light(int _nCode) {
      this.nCode = _nCode;
    }
    @Override
    public String toString() {
      return String.valueOf(this.nCode);
    }
  }
  /**
   */ 
   * @param args
   */
  public static void main(String[] args) {
    // 1. Scansione di tipi enum
    System.out.println("Demonstrazione della scansione di tipi enum ......");
    testTraversalEnum();
    // 2. Demonstrazione dell'uso dell'oggetto EnumMap
    System.out.println("Demonstrazione dell'uso e della scansione dell'oggetto EnumMap.....");
    testEnumMap();
    // 3. Demonstrazione dell'uso di EnumSet
    System.out.println("Demonstrazione dell'uso e della scansione dell'oggetto EnumSet.....");
    testEnumSet();
  }
  /**
   */ 
   * Demonstrazione della scansione di tipi enum
   */
  private static void testTraversalEnum() {
    Light[] allLight = Light.values();
    for (Light aLight : allLight) {
      System.out.println("Nome dell'attuale luce: " + aLight.name());
      System.out.println("Ordinal dell'attuale luce: " + aLight.ordinal());
      System.out.println("L'attuale luce: " + aLight);
    }
  }
  /**
   */ 
   * Demonstrazione dell'uso di EnumMap, EnumMap è simile all'uso di HashMap, ma i key devono essere di tipo enum
   */
  private static void testEnumMap() {
    // 1. Demonstrazione della definizione dell'oggetto EnumMap, il costruttore dell'oggetto EnumMap richiede un parametro da passare, di default è il tipo della chiave
    EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>;
    Light.class);
    currEnumMap.put(Light.RED, "Red Light");
    currEnumMap.put(Light.GREEN, "semaphore verde");
    currEnumMap.put(Light.YELLOW, "semaphore giallo");
    // 2. Esplorazione dell'oggetto
    for (Light aLight : Light.values()) {
      System.out.println("[key=" + aLight.name() + ",value="
      + currEnumMap.get(aLight) + "]");
    }
  }
  /**
   */ 
   /* Dimostra come usare EnumSet, EnumSet è una classe astratta, ottieni i contenuti di tipo enum di un tipo <BR/>
   */ 
   /* Puoi usare il metodo allOf
   */
  private static void testEnumSet() {
    EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
    for (Light aLightSetElement : currEnumSet) {
      System.out.println("I dati correnti dell'EnumSet sono: " + aLightSetElement);
    }
  }
}

Il risultato dell'esecuzione è il seguente:

Dimostrazione della scansione dell'enumerazione del tipo.....

Il nome dell'indicatore corrente: RED

L'ordinale dell'indicatore corrente: 0

L'indicatore corrente: 1

Il nome dell'indicatore corrente: GREEN

L'ordinale dell'indicatore corrente: 1

L'indicatore corrente: 3

Il nome dell'indicatore corrente: YELLOW

L'ordinale dell'indicatore corrente: 2

L'indicatore corrente: 2

Dimostrazione dell'uso e dell'esplorazione dell'oggetto EnumMap.....

[key=RED,value=semaphore rosso]

[key=GREEN,value=semaphore verde]

[key=YELLOW,value=semaphore giallo]

Dimostrazione dell'uso e dell'esplorazione dell'oggetto EnumSet.....

I dati correnti dell'EnumSet sono: 1

I dati correnti dell'EnumSet sono: 3

I dati correnti dell'EnumSet sono: 2

Quarto, la differenza tra il metodo di definizione delle costanti e il metodo di definizione delle costanti delle enum

Il seguente contenuto potrebbe essere un po' noioso, ma assolutamente degno di essere esplorato

1. Codice:

public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}

Cosa c'è di male, tutti lo hanno usato per molto tempo, non ci sono problemi

Prima di tutto, non è sicuro per il tipo. Devi assicurarti che sia int

其次，你还要确保它的范围是0和1

最后，很多时候你打印出来的时候，你只看到 1 和0 ，

in secondo luogo, devi assicurarti che il suo intervallo sia 0 e 1

34. Infine, molte volte quando lo stampi, vedi solo 1 e 0 ,

ma chi non vede il codice non sa dei tuoi intenti, abbandona tutte le vecchie costanti public static final

2. È possibile creare una classe enum, vederla come una classe comune. Tranne per il fatto che non può ereditare altre classi. (Java è un singolo erede, ha già ereditato Enum),

3. Il parametro switch() può utilizzare enum.

5. Non è possibile ereditare sottoclasse da enum, se si desidera estendere gli elementi dell'enum, creare un'enumerazione che implementi un'interfaccia all'interno di una classe, in modo da raggruppare gli elementi. Arrivare a raggruppare gli elementi dell'enum.

6. Utilizzare EnumSet al posto dei flag. enum richiede che i membri siano unici, ma non è possibile eliminare o aggiungere elementi nell'enum.

7. La chiave di EnumMap è enum e il valore è qualsiasi altro oggetto Object.

8. enum permette ai programmatori di scrivere metodi per le istanze di enum. Quindi, ogni istanza di enum può avere comportamenti diversi.

9. Utilizzo di enum per catena di responsabilità (Chain of Responsibility). Questo riguarda lo schema di design della catena di responsabilità. Affrontare un problema in diversi modi diversi e poi connetterli insieme. Quando arriva una richiesta, esplora la catena fino a che un'implementazione della soluzione può gestire la richiesta.

10. Utilizzo di enum per macchina a stati.

11. Utilizzo di enum per distribuzione multipla.

　Grazie per aver letto, spero di essere stato d'aiuto, grazie per il supporto al nostro sito!