Java opsommingen

In deze zelfstudie leren we over opsommingen in Java. We zullen leren om enums en enum-klassen te maken en te gebruiken met behulp van voorbeelden.

In Java is een enum (afkorting van enumeratie) een type met een vaste set constante waarden. We gebruiken de enum trefwoord om opsommingen te declareren. Bijvoorbeeld,

enum Size { 
   SMALL, MEDIUM, LARGE, EXTRALARGE 
}

Hier hebben we een opsomming gemaakt met de naam Size . Het bevat vaste waarden KLEIN , MEDIUM , GROOT , en EXTRALARGE .

Deze waarden binnen de accolades worden enumconstanten (waarden) genoemd.

Opmerking: De enum-constanten worden meestal weergegeven in hoofdletters.

Voorbeeld 1:Java Enum

enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
}

class Main {
   public static void main(String[] args) {
      System.out.println(Size.SMALL);
      System.out.println(Size.MEDIUM);
   }
}

Uitvoer

SMALL
MEDIUM

Zoals we in het bovenstaande voorbeeld kunnen zien, gebruiken we de naam enum om toegang te krijgen tot de constante waarden.

We kunnen ook variabelen van enum-typen maken. Bijvoorbeeld,

Size pizzaSize;

Hier, pizzaSize is een variabele van de Size type. Het kan alleen worden toegewezen met 4 waarden.

pizzaSize = Size.SMALL;
pizzaSize = Size.MEDIUM;
pizzaSize = Size.LARGE;
pizzaSize = Size.EXTRALARGE;

Voorbeeld 2:Java Enum met de switch-instructie

enum Size {
 SMALL, MEDIUM, LARGE, EXTRALARGE
}

class Test {
 Size pizzaSize;
 public Test(Size pizzaSize) {
   this.pizzaSize = pizzaSize;
 }
 public void orderPizza() {
   switch(pizzaSize) {
     case SMALL:
       System.out.println("I ordered a small size pizza.");
       break;
     case MEDIUM:
       System.out.println("I ordered a medium size pizza.");
       break;
     default:
       System.out.println("I don't know which one to order.");
       break;
   }
 }
}

class Main {
 public static void main(String[] args) {
   Test t1 = new Test(Size.MEDIUM);
   t1.orderPizza();
 }
}

Uitvoer

I ordered a medium size pizza.

In het bovenstaande programma hebben we een opsomming gemaakt van het type Size . Vervolgens hebben we een variabele pizzaSize . gedeclareerd van de Maat typ.

Hier de variabele pizzaSize kan alleen worden toegewezen met 4 waarden (SMALL , MEDIUM , GROOT , EXTRA GROOT ).

Let op de verklaring,

Test t1 = new Test(Size.MEDIUM);

Het zal de Test() . aanroepen constructor binnen de Test klas. Nu, de variabele pizzaSize is toegewezen aan de MEDIUM constant.

Op basis van de waarde wordt een van de gevallen van het switch case-statement uitgevoerd.

Enum-klasse in Java

In Java worden enum-typen beschouwd als een speciaal type klasse. Het werd geïntroduceerd met de release van Java 5.

Een enum-klasse kan methoden en velden bevatten, net als gewone klassen.

enum Size {
    constant1, constant2, …, constantN;

    // methods and fields	
}

Wanneer we een enum-klasse maken, maakt de compiler instanties (objecten) van elke enum-constante. Ook is alle enum-constante altijd public static final standaard.

Voorbeeld 3:Java Enum-klasse

enum Size{
  SMALL, MEDIUM, LARGE, EXTRALARGE;

  public String getSize() {

    // this will refer to the object SMALL
    switch(this) {
      case SMALL:
        return "small";

      case MEDIUM:
        return "medium";

      case LARGE:
        return "large";

      case EXTRALARGE:
        return "extra large";

      default:
        return null;
      }
   }

  public static void main(String[] args) {

    // call getSize()
    // using the object SMALL
    System.out.println("The size of the pizza is " + Size.SMALL.getSize());
  }
}

Uitvoer

The size of the pizza is small

In het bovenstaande voorbeeld hebben we een enum-klasse gemaakt Size . Het heeft vier constanten SMALL , MEDIUM , GROOT en EXTRALARGE .

Sinds Maat is een enum-klasse, de compiler maakt automatisch instanties voor elke enum-constante.

Hier binnen de main() methode hebben we de instantie SMALL . gebruikt om de getSize() . te bellen methode.

Opmerking :Net als reguliere klassen, kan een enum-klasse ook constructors bevatten. Ga naar Java enum constructor voor meer informatie.

Methoden van Java Enum Class

Er zijn enkele vooraf gedefinieerde methoden in enum-klassen die direct beschikbaar zijn voor gebruik.

1. Java Enum ordinaal()

De ordinal() methode retourneert de positie van een enum-constante. Bijvoorbeeld,

ordinal(SMALL) 
// returns 0

2. Enum CompareTo()

De compareTo() methode vergelijkt de enum constanten op basis van hun ordinale waarde. Bijvoorbeeld,

Size.SMALL.compareTo(Size.MEDIUM)
 // returns ordinal(SMALL) - ordinal(MEDIUM)

3. Enum toString()

De toString() methode retourneert de tekenreeksrepresentatie van de enum-constanten. Bijvoorbeeld,

SMALL.toString()
// returns "SMALL"

4. Enum naam()

De name() methode retourneert de gedefinieerde naam van een enum-constante in tekenreeksvorm. De geretourneerde waarde van de name() methode is final . Bijvoorbeeld,

name(SMALL)
// returns "SMALL"

5. Java Enum valueOf()

De valueOf() methode neemt een string en retourneert een enum-constante met dezelfde stringnaam. Bijvoorbeeld,

Size.valueOf("SMALL")
// returns constant SMALL.

6. Enum waarden()

De values() methode retourneert een array van het enum-type die alle enum-constanten bevat. Bijvoorbeeld,

Size[] enumArray = Size.value();

Waarom Java Enums?

In Java werd enum geïntroduceerd om het gebruik van int-constanten te vervangen .

Stel dat we een verzameling van int . hebben gebruikt constanten.

class Size {
   public final static int SMALL = 1;
   public final static int MEDIUM = 2;
   public final static int LARGE = 3;
   public final static int EXTRALARGE = 4;
}

Hier ontstaat het probleem als we de constanten afdrukken. Het is omdat alleen het nummer wordt afgedrukt, wat misschien niet handig is.

Dus in plaats van int-constanten te gebruiken, kunnen we eenvoudig enums gebruiken. Bijvoorbeeld,

enum Size {
   SMALL, MEDIUM, LARGE, EXTRALARGE
}

Dit maakt onze code intuïtiever.

Enum biedt ook compileer-time type veiligheid .

Als we een variabele van de Size . declareren type. Bijvoorbeeld,

Size size;

Hier wordt gegarandeerd dat de variabele een van de vier waarden zal bevatten. Als we nu andere waarden dan die vier waarden proberen door te geven, zal de compiler een fout genereren.