Definition. Enums

[comp1110-2G]
  • Liam O'Connor, Fabian Muehlboeck

An enum (short for enumeration) is a user-definable type whose values come from a fixed finite list. Instead of using arbitrary integers or strings, we define a small set of allowed values and give each one a name. For example:

enum Month { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER }

This defines a new type called Month. A variable of type Month can only hold one of these twelve values. For example:

Month m = Month.AUGUST;

The names (which are by convention written in ALL_CAPS) inside the enum definition are called constants. They are always written with the type name in front, such as Month.JANUARY or Month.DECEMBER. This prevents confusion if different enums contain constants with the same name.

Context

    Creating a finite type

    [comp1110-2M]
    • Liam O'Connor, Fabian Muehlboeck

    Definition. Enums

    [comp1110-2G]
    • Liam O'Connor, Fabian Muehlboeck

    An enum (short for enumeration) is a user-definable type whose values come from a fixed finite list. Instead of using arbitrary integers or strings, we define a small set of allowed values and give each one a name. For example:

    enum Month { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER }

    This defines a new type called Month. A variable of type Month can only hold one of these twelve values. For example:

    Month m = Month.AUGUST;

    The names (which are by convention written in ALL_CAPS) inside the enum definition are called constants. They are always written with the type name in front, such as Month.JANUARY or Month.DECEMBER. This prevents confusion if different enums contain constants with the same name.

    The benefits of enums

    [comp1110-2J]
    • Liam O'Connor, Fabian Muehlboeck

    One advantage of enums is that they help make illegal states unrepresentable. If we represent months using integers or strings, the program could accidentally produce values that are not valid months (such as "Spring" or -2). By defining a Month enum, we restrict the variable to a fixed set of valid values (JANUARY, FEBRUARY, MARCH, and so on). The compiler then ensures that no other values can appear. This prevents many kinds of mistakes and makes programs easier to reason about, because whenever we see a variable of type Month, we know it must be one of those twelve possibilities.

    Example. A Month from User Input

    [comp1110-2H]
    • Liam O'Connor, Fabian Muehlboeck
     void main(String args[]) { int month = Integer.parseInt(args[0]); Month m; if (month == 1) { m = Month.JANUARY; } else if (month == 2) { m = Month.FEBRUARY; } else if (month == 3) { m = Month.MARCH; } else if (month == 4) { m = Month.APRIL; } else if (month == 5) { m = Month.MAY; } else if (month == 6) { m = Month.JUNE; } else if (month == 7) { m = Month.JULY; } else if (month == 8) { m = Month.AUGUST; } else if (month == 9) { m = Month.SEPTEMBER; } else if (month == 10) { m = Month.OCTOBER; } else if (month == 11) { m = Month.NOVEMBER; } else { m = Month.DECEMBER; } IO.println(m.toString()); }

    The final line in the above function also demonstrates that enum types have a built in .toString() method that converts to the string representation of the constant name.

    Warning. Enums are reference types

    [comp1110-2I]
    • Liam O'Connor, Fabian Muehlboeck

    In Java, enum values are technically things that reside in memory, like Strings and arrays: each constant such as Month.JANUARY or Month.AUGUST has its own place in memory. However, for each constant there is exactly one object created by the Java runtime. This means every time the program refers to Month.JANUARY, it refers to the same object. Because there is only one instance of each constant, it is safe to compare enum values using ==. The comparison simply checks whether the two references point to the same object, which correctly tells us whether the two enum values are the same.

    Construction. The switch statement on enums

    [comp1110-2K]
    • Liam O'Connor, Fabian Muehlboeck

    Java provides a convenient way to perform different actions depending on an enum value: the switch statement.

    void printShortMonthName(Month m) { switch (m) { case JANUARY -> IO.println("Jan"); case FEBRUARY -> IO.println("Feb"); case MARCH -> IO.println("Mar"); case APRIL -> IO.println("Apr"); case MAY -> IO.println("May"); case JUNE -> IO.println("Jun"); case JULY -> IO.println("Jul"); case AUGUST -> IO.println("Aug"); case SEPTEMBER -> IO.println("Sep"); case OCTOBER -> IO.println("Oct"); case NOVEMBER -> IO.println("Nov"); case DECEMBER -> IO.println("Dec"); } }

    The switch examines the value of g. Each line specifies what to do for one possible value. If m is Month.MARCH, for example, the program prints "Mar".

    Notice that inside the switch we write the constants without the Month. prefix. Java already knows that m has type Month, so it knows which constants we mean.

    Warning. The old-style switch statement

    [comp1110-2L]
    • Liam O'Connor, Fabian Muehlboeck

    Older versions of Java used a different syntax for switch statements:

    switch (m) { case JANUARY: IO.println("Jan"); break; case FEBRUARY: IO.println("Feb"); break; ... }

    This version uses case labels and colons, and each branch usually ends with break. If break is omitted, execution falls through into the next case, which often causes mistakes. Therefore, in this course we will use the arrow form and not the older colon style.

    Construction. The switch expression on enums

    [comp1110-76]
    • Liam O'Connor, Fabian Muehlboeck

    switch is a control structure, like if and while. In contrast to these two, however, switch can also be used as an expression form, which means it can be used as the right-hand side of an assignment. For example:

    int daysInMonth(Month m, boolean isLeapYear) { int days = switch (m) { case JANUARY -> 31; case FEBRUARY -> { if (isLeapYear) { yield 29; } else { yield 28; } } case MARCH -> 31; case APRIL -> 30; case MAY -> 31; case JUNE -> 30; case JULY -> 31; case AUGUST -> 31; case SEPTEMBER -> 30; case OCTOBER -> 31; case NOVEMBER -> 30; case DECEMBER -> 31; }; // Note the semicolon here return days; }

    In this case, it is important that each case of the switch expression returns a value of a suitable type. If you need more complicated logic for a case, you can have a code block enclosed in curly braces, where the special yield statement works like a sort of local return statement.

    This form is not really important for this course, but you may encounter it in newer Java code.

    Construction. Larger types and the default case for switch

    [comp1110-78]
    • Fabian Muehlboeck

    The switch statements/expressions do not just work on enum values - in fact, they can distinguish between values of a wide variety of types. Modern Java uses them to implement a kind of pattern-matching you might be used to from Haskell (but do not worry if you are not - if at all, we will only see that towards the end of this course). You can also use them on strings or integers. But those have many possible values - you don't really want to be writing cases for each and every one of them!

    Any switch statement or expression can contain a default case for all other values not captures by previous cases. In addition, individual cases can capture multiple values, like so:

    boolean isSummer(Month m) { return switch(m) { case DECEMBER, JANUARY, FEBRUARY -> true; default -> false; }; }

    And similarly, you can do the same for Strings:

    boolean isSummer(String m) { return switch(m) { case "Dec", "Jan", "Feb" -> true; default -> false; }; }

    The main difference here is that the latter works for all kinds of Strings, so you need to be careful about what your catch-all default case expresses. Here, the string "December" would return false, too!

    Backlinks

      Example. A Month from User Input

      [comp1110-2H]
      • Liam O'Connor, Fabian Muehlboeck
       void main(String args[]) { int month = Integer.parseInt(args[0]); Month m; if (month == 1) { m = Month.JANUARY; } else if (month == 2) { m = Month.FEBRUARY; } else if (month == 3) { m = Month.MARCH; } else if (month == 4) { m = Month.APRIL; } else if (month == 5) { m = Month.MAY; } else if (month == 6) { m = Month.JUNE; } else if (month == 7) { m = Month.JULY; } else if (month == 8) { m = Month.AUGUST; } else if (month == 9) { m = Month.SEPTEMBER; } else if (month == 10) { m = Month.OCTOBER; } else if (month == 11) { m = Month.NOVEMBER; } else { m = Month.DECEMBER; } IO.println(m.toString()); }

      The final line in the above function also demonstrates that enum types have a built in .toString() method that converts to the string representation of the constant name.

      Construction. Access Modifiers

      [comp1110-7W]
      • Fabian Muehlboeck

      Data type definitions (e.g. Enums and Class Definitions) and members may be given an access modifier. The following access modifiers exist in Java:

      • public - this means that the data type or member should be accessible by everyone, from anywhere.
      • private - this means that the data type or member should only be accessible from within the scope of the outermost enclosing context.
      • protected - this will be explained later and is not important for now.

      In addition to these modifiers, the meaning of not having a modifier at all is called package private. These data types or members are accessible from everywhere in the same package, as if they were public, but inaccessible from outside of that package, as if they were private.

      Access modifiers are about syntactic scope, that is, about how code is written and nested. In particular, any private field can be accessed from any code within the same class, not just from within the same object.

      Construction. Class Definitions

      [comp1110-80]
      • Fabian Muehlboeck

      In Java, objects are instances of classes. A class definition is a kind of data definition, similar to what we have seen before for enums. However, classes are much more powerful, and they are used to model pretty much everything in our programs that cannot be modeled by a simpler data type. The core parts we will deal with for now are fields, which contain an object's data, and methods, which define an object's behaviour. The basic definition of a class consists of the keyword class and a class name, followed by curly braces, like so:

      class Person { //this is where the fields and methods of a class go }

      This does define a new type Person. To create a new instance of it (i.e. an object), you could write something simliar to what we did for arrays, using the keyword new:

      Person p = new Person();

      This is not very useful, because the Person class above has no data or behaviour, but you can add those.

      By convention, class names in Java should be nouns that start with a capital letter, and use capital letters to mark the start of any word internal to the name. For example: LectureNote .

      Construction. Fields

      [comp1110-81]
      • Fabian Muehlboeck

      Every class can have arbitrarily many fields. At the very least, each field has a type and name, just like a local variable. There are some other properties that fields can have, which we'll see later. To define a field, you declare it just like a local variable:

      String name;

      You can also give the field a default value, just like a local variable definitions:

      String name = "Unknown";

      By convention, in Java, field names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

      In principle, you can read and write the fields of an object similar to how you can read and write individual array elements, though the syntax is more like when you ask an array for its length:

      String oname = obj.name; if(oname.equals("Unknown")) { obj.name = "Timmy"; }

      Warning. 

      • Fabian Muehlboeck
      Note that array.length has the special property that you cannot assign values to it.

      Example. Fields

      [comp1110-82]
      • Fabian Muehlboeck

      Say we want our Person class from earlier to have two fields: one representing the name of the person, and one representing their age. Names would typically be represented as Strings, and in our case, we only care about completed years of age, so we use int as the type for that field.

      class Person { int age; String name; }

      We can then create a new Person value and write to its fields:

      Person p = new Person(); p.name = "Timmy"; p.age = 5;

      Warning. 

      • Fabian Muehlboeck
      This is not how you would typically do this; we'll learn about the right way to do this later.

      Construction. Methods

      [comp1110-83]
      • Fabian Muehlboeck

      So far, we have sometimes written code in separate functions from the main function. But in every case so far, we had to give those functions all the arguments that they were supposed to work with.

      Methods defined in a class implicitly have access to the fields defined in that class. This is because methods always need to be called on a specifc object, whose field values can then be used within the method.

      So in principle, writing a method is just like writing a function, except inside a class. Within the class, you can all other methods within the class just like we called functions before.

      By convention, in Java, method names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

      class MyClass { int myMethod() { return 42; } }

      Example. Methods

      [comp1110-84]
      • Fabian Muehlboeck

      Building on our example from Example [comp1110-82], imagine we want to just have a way to print a nice description for any of our basic Person objects.

      To do this, we'll add a printDescription method to the class:

      class Person { int age; String name; void printDescription() { IO.println(name + " (Age " + age + ")"); } }

      We can try this with the following main function:

      void main() { Person p = new Person(); p.name = "Timmy"; p.age = 5; p.printDescription(); }

      This will print:

      Timmy (Age 5)

      Have we seen Objects before?

      [comp1110-85]
      • Fabian Muehlboeck

      Yes! Every string and array is an object. When we wrote guess.charAt(5), we were calling a method of the String class on the particular String object referred to by guess.

      Similarly, the difference between arr.length for arrays and str.length() for strings is that the former is a field that we can access, and the latter is a method we have to call.

      Warning. Enums are reference types

      [comp1110-2I]
      • Liam O'Connor, Fabian Muehlboeck

      In Java, enum values are technically things that reside in memory, like Strings and arrays: each constant such as Month.JANUARY or Month.AUGUST has its own place in memory. However, for each constant there is exactly one object created by the Java runtime. This means every time the program refers to Month.JANUARY, it refers to the same object. Because there is only one instance of each constant, it is safe to compare enum values using ==. The comparison simply checks whether the two references point to the same object, which correctly tells us whether the two enum values are the same.

      Construction. Larger types and the default case for switch

      [comp1110-78]
      • Fabian Muehlboeck

      The switch statements/expressions do not just work on enum values - in fact, they can distinguish between values of a wide variety of types. Modern Java uses them to implement a kind of pattern-matching you might be used to from Haskell (but do not worry if you are not - if at all, we will only see that towards the end of this course). You can also use them on strings or integers. But those have many possible values - you don't really want to be writing cases for each and every one of them!

      Any switch statement or expression can contain a default case for all other values not captures by previous cases. In addition, individual cases can capture multiple values, like so:

      boolean isSummer(Month m) { return switch(m) { case DECEMBER, JANUARY, FEBRUARY -> true; default -> false; }; }

      And similarly, you can do the same for Strings:

      boolean isSummer(String m) { return switch(m) { case "Dec", "Jan", "Feb" -> true; default -> false; }; }

      The main difference here is that the latter works for all kinds of Strings, so you need to be careful about what your catch-all default case expresses. Here, the string "December" would return false, too!

      Construction. The switch statement on enums

      [comp1110-2K]
      • Liam O'Connor, Fabian Muehlboeck

      Java provides a convenient way to perform different actions depending on an enum value: the switch statement.

      void printShortMonthName(Month m) { switch (m) { case JANUARY -> IO.println("Jan"); case FEBRUARY -> IO.println("Feb"); case MARCH -> IO.println("Mar"); case APRIL -> IO.println("Apr"); case MAY -> IO.println("May"); case JUNE -> IO.println("Jun"); case JULY -> IO.println("Jul"); case AUGUST -> IO.println("Aug"); case SEPTEMBER -> IO.println("Sep"); case OCTOBER -> IO.println("Oct"); case NOVEMBER -> IO.println("Nov"); case DECEMBER -> IO.println("Dec"); } }

      The switch examines the value of g. Each line specifies what to do for one possible value. If m is Month.MARCH, for example, the program prints "Mar".

      Notice that inside the switch we write the constants without the Month. prefix. Java already knows that m has type Month, so it knows which constants we mean.

      Values vs. Entities

      [comp1110-3C]
      • Liam O'Connor, Fabian Muehlboeck

      Think of the number 5. If you add 1 to it, you don't "change" the 5; you simply produce to a completely different value, 6. The number 5 is immutable and has no identity other than its value. Enums behave like this, which is why you can compare them with ==. Strings, on the other hand, are immutable, but have identity, so there can be two String entities that represent the same text, but are different entities, and so == does not work.

      Now think about your bank account. If you deposit 100 dollars into your bank account, you don't get a new bank account, rather, your existing bank account is updated to reflect the new reality. This is also important when there are multiple people accessing the same bank account - they should see the same data, which would not be true if everyone kept creating new copies of it every time they change something. We saw this concept before when sorting arrays and when Inserting into a binary search tree.

      bars magnifying-glass caret-down plus minus arrow-right xmark