Enums, lambdas, and functional interfaces

This lesson has two ideas. The first is a type whose values are a small, fixed set of names, such as the days of the week or the suits in a pack of cards. The second is a way to hand a piece of behavior to a method, the way you already hand it a number. At the end the two meet, in an enum whose values each carry their own behavior.

Numbers standing in for meanings#

Suppose a program needs to track the day of the week. With the tools you have, you might use plain int constants, the kind of class constant you met in static and final:

This compiles and runs, and that is the problem. today is an int, so Java happily lets it hold 99, or -4, or any other number that is not a day at all. A method that takes a day really takes an int, and whoever reads the code has to remember that 2 means Wednesday. The meaning lives in your head, not in the program.

Key idea

When the valid values of something form a small, fixed set, an int is too loose. It allows billions of values you never meant to be legal, and it throws away the names.

An enum: a type with a fixed set of named values#

An enum (short for enumeration, a list of things named one by one) is a type you define whose only legal values are the ones you name. You list them once, and from then on a variable of that type can hold one of those values and nothing else.

It prints Today is WED and The shop is open. Read the declaration first. enum Day introduces a new type called Day, just as writing a class does. Inside the braces is the complete list of values it can ever have, MON to SUN. Each one is a constant, so they are written in capitals.

Day today = Day.WED; reads almost like English: today is a Day, set to Wednesday. You reach a value with the type name, a dot, then the value. Try Day today = Day.FUNDAY; and the program does not compile: javac reports cannot find symbol, because FUNDAY is not in the list. The mistake that the int version let through is caught before the program runs.

An enum is a class#

An enum is a special kind of class. Each constant is an object of that class, made once when Java sets up the enum, and Java declares each one as a public static final field of the enum. That is why you write Day.WED, the same way you wrote Goblin.count in static and final. Every enum quietly extends Java's class java.lang.Enum, which gives it methods such as name() and ordinal(), and Java writes two more, values() and valueOf, for each enum you declare.

You cannot make more Day objects. new Day() does not compile; javac says enum classes may not be instantiated. The seven constants are all the days there will ever be.

Enums in a switch#

Because an enum has a small, known set of values, it pairs naturally with switch. In the caselabels you write the constant's name on its own, without Day. in front, because the switch already knows it is looking at a Day.

Trace it. today is FRI. The switch jumps to case FRI, prints Almost the weekend, and the break stops it falling into default. The two weekend cases stacked together, SAT then SUN with nothing between them, share one action: that is the deliberate fall-through you met in the switch lesson.

The arrow form and switch expressions work on enums too, and with an enum they bring one extra benefit:

It prints Weekend and A working day. Notice there is no default. A switch expression must produce a value for every possible input, and for an enum javac can check the list: these cases cover all seven days. Leave THU out and javac refuses with the switch expression does not cover all possible input values. So if you later add a constant to the enum, every switch expression that forgot it stops compiling, and the compiler points you at each place to fix.

1public class Main {
2 
3    enum Light {
4        RED, YELLOW, GREEN
5    }
6 
7    static String action(Light light) {
8        return "?"; // TODO: a switch expression that gives Stop, Slow down or Go
9    }
10 
11    public static void main(String[] args) {
12        for (Light light : Light.values()) {
13            System.out.println(light + ": " + action(light));
14        }
15    }
16}

Built-in methods: values, ordinal, name and valueOf#

Every enum gets a few methods for free. values()hands back an array of all the constants in the order you declared them, so you can loop over them. Each constant's ordinal() is its position in that list, counting from 0, and name() is its name as a String. valueOf goes the other way, from a name to the constant.

The loop prints each direction with its position, 0 to 3. valueOf("EAST") finds the constant, so the next line prints EAST true. The last lookup fails: names must match exactly, capital letters included, so valueOf("east") stops the program with an IllegalArgumentException and the message No enum constant Main.Direction.east.

ordinal() and values() together let you step through the list. Decide what this prints.

It prints THU and MON. For WED, ordinal() is 2, so next picks position 3, THU. For SUN, ordinal() is 6; 6 + 1 is 7, and 7 % 7 is 0, so the week wraps around to MON. The % keeps the position inside the array.

Fields, constructors and methods#

Since an enum is a class, each constant can carry its own data, and the enum can have methods. Suppose each planet should know its own gravity, so that it can work out what something weighs there.

It prints On Earth: 686.0 and On Jupiter: 1736.0. Each constant is written with a number after it, like EARTH(9.8). That number goes to the enum's constructor, which stores it in the gravity field of that constant. weightFor is an ordinary method using the field: Planet.EARTH.weightFor(70.0) is 70.0 * 9.8, which is 686.0.

Two rules come with this. The list of constants comes first and ends with a semicolon; the fields, constructor and methods follow it. Put the field first and javac stops with enum constant expected here. And you never call the constructor with new: Java calls it once for each constant, with the values in that constant's parentheses.

Behavior you want to pass around#

Now the second idea. So far, when you wanted to give a method some information, you passed a value: a number, a string, an object. Sometimes the thing you want to hand over is an action: “take these two numbers and do this to them”. How do you package an action so it can be passed like a value?

You already have the tool: an interface. Define an interface with one method that describes the shape of the action, and any object that implements it is a packaged action you can pass around.

Look closely at compute. Its first parameter is an Operation: an action. It does not know or care what the action does; it calls op.apply(a, b) and returns the result. Hand it an Add object, and compute(add, 3, 4) runs add.apply(3, 4), which is 3 + 4, so the program prints 3 add 4 = 7. The behavior was passed in, and compute could just as well subtract or multiply, depending only on which Operation it is given.

Operation is declared inside Main, so the Add class outside it calls it Main.Operation, just as Person.Address was named in inner classes. An interface declared inside a class is always static, so using it needs no Main object.

Notice that the interface has exactly one method. That matters enough to have a name: an interface with exactly one abstract method is a functional interface. With only one method, there is no doubt about what implementing it means: there is one job to fill in.

Key idea

A functional interface is an interface with exactly one abstract method. Because there is only one method to provide, Java lets you provide just that method's body, with no class and no ceremony. That shortcut is the lambda.

The ceremony problem#

Writing a whole separate Add class to carry one line of logic, a + b, is a lot of packaging for very little content. You met one way to trim it in inner classes: an anonymous class, which implements the interface on the spot without naming a class.

Better, but still noisy. The only part that says anything is return a + b;. Everything around it, new Operation() { public int apply(int a, int b) { ... } }, is scaffolding the compiler could work out for itself. It already knows the type is Operation, that the one method is apply, and what its parameter types are.

The lambda: just the body of the one method#

A lambdais a compact way to write that one method's body and nothing else. You give the parameters, an arrow ->, and the result. Java fills in the rest from the interface.

It prints 3 add 4 = 7 and 3 multiply 4 = 12. Step through it and watch what happens when compute calls op.apply(a, b): the trace jumps into the lambda's body. Read (a, b) -> a + b as “given a and b, produce a + b”. The left of the arrow is the parameters; the right is what to return. There is no method name, because Operation has only one method. There are no parameter types, because Java reads them from apply(int a, int b).

add is still an Operation, a value you can store in a variable and pass to compute exactly as before. It is the same machinery as the class version, with almost none of the noise.

Lambda shapes#

A lambda's shape follows the method it implements:

• No parameters: empty parentheses, as in () -> "Hello!". That is the shape you copied for assertThrows in testing with JUnit.
• One parameter: the parentheses may be left out, as in n -> n % 2 == 0. That is the shape of the rule you gave removeIf.
• Two or more parameters: parentheses, as in (a, b) -> a * b.
• A body of several statements: braces, with return written out, as in an ordinary method.

It prints Hello!, false true and 16. Each lambda is called through its interface's one method: make, test and apply.

Creating a lambda and running it are two separate moments. Decide what this program prints, and in what order.

It prints lambda made, then working on 3 and 4, then 12. Creating the lambda runs none of its body; it only packages the code. The body runs when op.apply(3, 4) calls it, and it would run again on every later call.

Methods that take behavior#

The point of all this is to write methods that take behavior as a parameter. countMatching below counts how many numbers pass a test, and the test itself is a parameter: whoever calls the method decides what passing means.

1public class Main {
2 
3    interface Check {
4        boolean test(int n);
5    }
6 
7    static int countMatching(int[] numbers, Check check) {
8        int count = 0;
9        for (int n : numbers) {
10            if (check.test(n)) {
11                count++;
12            }
13        }
14        return count;
15    }
16 
17    public static void main(String[] args) {
18        int[] scores = { 72, 45, 90, 38, 66, 50 };
19 
20        Check passed = n -> false;    // TODO: 50 or more
21        Check even = n -> false;      // TODO: even numbers
22        Check inForties = n -> false; // TODO: from 40 to 49
23 
24        System.out.println("passed: " + countMatching(scores, passed));
25        System.out.println("even: " + countMatching(scores, even));
26        System.out.println("in the forties: " + countMatching(scores, inForties));
27    }
28}

Ready-made functional interfaces#

You do not have to write a new interface for every shape of behavior. The package java.util.function holds dozens of general-purpose functional interfaces, and most code uses those. The type in angle brackets says what the behavior works on, as in ArrayList<String>, and Integer stands in for int there, as you saw in ArrayList. Here are the six you will meet most:

It prints true, 4, HEY! and Hello. The type of each variable names the interface, so you call its one method by name: test, apply, accept and get.

Now you can read the rule you handed to removeIf. ArrayList's removeIf takes a Predicate and calls its test method on every element, removing the ones that pass. forEach takes a Consumer and calls it on every element:

It prints kept 72 and kept 90. Inside removeIf, Java calls your lambda once for each score and removes 45 and 38, the two for which it answered true. Then forEach calls the second lambda once for each score that is left.

Behavior as a value#

A lambda is a value. You can keep it in a variable, as you have been doing, and you can also put it in an array, pass it to a method and return it from a method. A language in which functions can be handled like any other value is said to have first-class functions. Java gets there through functional interfaces: the interface is the type, and the lambda is the value.

It prints add(6, 2) = 8, subtract(6, 2) = 4 and multiply(6, 2) = 12. An array of behaviors: ops[0] adds, ops[2] multiplies, and the loop calls each one on the same two numbers. Nothing about arrays had to change for them to hold actions.

A method can also build a lambda and hand it back:

It prints 15, 6 and 11. makeAdder(10) returns a lambda that remembers its amount, 10, and makeAdder(1) returns another that remembers 1. Each call makes a new lambda with its own amount, which it can keep because a parameter that never changes is effectively final. The last line feeds one result into the other: addOne.apply(0) is 1, and addTen.apply(1) is 11.

Method references: naming a method that already exists#

Sometimes a lambda does nothing but call a method that already exists, passing its arguments straight on: (a, b) -> Math.max(a, b) is like that. For this case Java has a shorter form, the method reference, written with two colons: Math::max.

It prints max of 8 and 5 is 8, sum of 8 and 5 is 13, then ADA and BEN. Each method reference stands for a lambda:

• Math::max and Integer::sum name static methods. They mean (a, b) -> Math.max(a, b) and (a, b) -> Integer.sum(a, b); Integer.sum simply adds two ints.
• String::toUpperCase names a method that each element runs on itself: word -> word.toUpperCase(). replaceAll takes a UnaryOperator and replaces every element with its result.
• System.out::println names a method of one particular object, System.out: name -> System.out.println(name).

Use a method reference when the lambda only passes its arguments on; otherwise keep the lambda. There is a fourth kind, for constructors, and streams puts all four side by side.

Putting the two ideas together#

Here the two halves of this lesson meet. A constant of an enum can carry data, and a lambda is a value, so each constant can carry its own behavior:

It prints 6 + 2 = 8, 6 - 2 = 4 and 6 * 2 = 12. Each constant hands a symbol and a lambda to the constructor, which stores both. The loop over Op.values()then uses each constant's own rule. Adding a DIVIDE constant later is one more line in the list, and the loop needs no change.

Key idea

An enum fixes the values a type may have. A lambda packs one piece of behavior into a value. Together they let each value of a type carry the behavior that belongs to it.

Further reading#

• Enums on dev.java, including fields, methods and a different body for each constant
• Writing your first lambdas on dev.java, the start of the official lambda tutorial
• The java.util.function package in the Java SE 25 API documentation, with every ready-made functional interface
• Enum classes in the Java Language Specification, section 8.9