Java functional interface

Introduction

Java is an object oriented programming language, meaning most of Java revolves around objects. One type of object that has been used since Java 1.8 is functional interfaces. Functional interfaces are a class that contains only a single abstract method. Functional interfaces are also known as Single Abstract Method Interfaces or SAM interfaces. These interfaces help to define behavior, and allow for the use of more precise and concise code. Some examples of function interfaces include: Runnable, Comparable, ActionListener, and Callable.

Runnable - It contains only the run() method. It is used to write applications that can run on a separate thread.
Comparable - This interface contains only the compareTo() method. The objects of the class that implements the Comparable interface can be compared and sorted.
ActionListener - It contains only the actionPerformed() method. It is responsible for handling all the action events like a mouse click on a component.
Callable - It only contains the call() method. This method is used to monitor the progress of a function being executed by a thread.

In Java 8 a new functionality was introduced called lambda expressions. In this article we will cover what the common functional interfaces are, lambda expressions, and overriding functions.

Java Functional Interfaces

The basis of a functional interface is that they only contain one abstract method. This does not mean that function interfaces can only contain one method though. Functional interfaces can also include any amount of static or default methods. The defining factor is that only one abstract method is ever included in the interface. In Java there is a @FunctionalInterface annotation. This annotation is optional but is recommended when defining a functional interface. This annotation will check the class to ensure it is following the rules of a function interface having only one abstract method. If it finds more than one abstract method it will throw a compiler warning. If more than one abstract method is added to a function interface it becomes a non-function interface.

Java Lambda Functions

Java lambda expressions are similar to anonymous or arrow functions that you may have used in other programming languages such as JavaScript. They allow developers to declare a functional interface without having to create a class for it. These functions similar to anonymous functions use a simple syntax that disregards a declaration. This has both advantages and disadvantages. It makes creating and utilizing a functional interface simple but the functional interface cannot be referenced in another place as there is no reference to call it by. If you are only using it in one place though, it greatly reduces the code needed.

Some examples of common places lambda functions can be used include:

ForEach - implements Consumer functional interface
ReplaceAll - implements Function functional interface
Generate - implements Supplier functional interface
Filter - implements Predicate functional interface

In each of these cases a lambda expression can be used, rather than creating an object that implements the functional interface. A lambda with Java can be created by declaring the arguments then using “->” followed by the body of the function enclosed in curly brackets. It will automatically use the function in place of the abstract method of the function interface. For example using the lambda in the forEach will treat the lambda expression as the implementation of the accept abstract method since forEach is a Consumer interface.

Another representation of a lambda method is the “::” symbol. This is called a method reference and can be applied whenever you are applying a non-static method of an instance or a static method of a class. These mean you need to provide the object type that contains the methods. For example the toUpperCase method is an instance-method of type String.

Java

//Example of lambda programming in Java
List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("bananas");
fruits.add("pears");

//Using lambda expression
fruits.replaceAll(fruit -> fruit.toUpperCase());
//or
//using double colons method reference
fruits.replaceAll(String::toUpperCase);

Method Types

Abstract Methods In Java

An abstract method is essential to a functional interface so it is important to know what that entails. Abstract methods are methods that do not include an implementation. This means they do not contain curly braces containing the functionality. It is then the responsibility of any class implementing the interface to define the functionality of the abstract method.

Static Methods In Java

A Java static function is a method that belongs to the class rather than any instance of the class. This means that you can call the static method directly without having to create an object of the class. This also denotes that static methods cannot directly access instance variables but can use static variables from the class. In addition the “this” key word cannot be used by a static method.

Default(Non-abstract) Methods In Java

Default methods were introduced in Java 8 so functional interfaces could access external functionality without breaking logic. Default methods within a functional interface cannot access the interface state as the interface cannot have a state. So in order to use non-static variables the default methods must use the abstract method. The abstract method can access the state of the parent object because it is defined in the parent. So by using the abstract method the default methods can perform operations on the parent objects state.

Java Function Interface

function interface

The first functional interface that is commonly implemented is the Function interface. The Function interface takes an argument and returns an argument. For example you can have an implementation of a function that takes a Long as a parameter. It would then calculate and return a result. In the example below this section it returns the factorial in Java. The Function interface has 4 built in methods: apply, andThen, compose, and identify.

Abstract

apply()

Takes a parameter and returns the result. This is the basic execution of a Function.

Default

andThen()

Takes a parameterized Function which is executed after the first Function. This means that it will take a parameter to execute the first Function and then use that result as the parameter to execute the next Function. This allows for Functions to be chained together and executed one before another.

compose()

Takes a parameterized Function which is executed before the first function. This means that it will take a parameter to execute the second function and then use that result as the parameter to execute the previous Function. This allows for Functions to be chained together and executed one after another.

Static

identify()

Takes a parameter and returns a function that returns the parameter.

There are some variations of the Function interface such as the biFunction which can take two arguments instead of just one. Other variations include IntFunction, LongFunction, and DoubleFunction which all must take the primitive type defined in the name as an argument. To be a Function interface it must take at least one augment and return an argument.

Java Unary Operator

Unary Operations are a special type of Function that is commonly used. Unary Operations take one argument and return an argument of the same type. By using this Function you are requiring the return to be the same type as the parameter.

Java Binary Operator

Binary Operations are similar to Unary Operations in that they return an argument of the same type. If the two parameters are different then the argument return will be of the same type as the greater argument. For example if the Binary Operation takes an int and a long then it must return a long.

Java

//Example of implementing a Function to get factorial Java code
public class multiplyNumbers implements Function<Long,Long> {
    @Override
    public Long apply(Long number) {
	 Long result = 1;
        for(int i = 2; i <= number; i++){
            result * i
        }
        return result;
    }
}

Java Predicate Interface

Another common functional interface that is used is the Predicate interface. A Predicate in coding is an expression that evaluates to either true or false. The Predicate interface works the same way. It takes an argument and returns a boolean value(true or false). Similar to the Function interface, the Predicate interface has a Bi-Predicate interface which takes two arguments rather than one. It also has the variation for primitive types including long, double, and int. The predicate interface has 5 built-in methods that are listed below.

Abstract

test()

Takes a parameter and returns a booleant. This is the basic execution of a Predicate.

Default

and()

Takes a parameterized Predicate and returns a boolean value. The boolean will be the logical and result between the two Predicate returns. So if both Predicates return true it will return true, otherwise it will return false.

or()

Takes a parameterized Predicate and returns a boolean value. The boolean will be the logical or result between the two Predicate returns. So if both Predicates return false it will return false, otherwise it will return true.

negate()

Returns a predicate that represents the logical negation of this Predicate. Meaning if the original Predicate returns true, adding the negate will return false instead. Likewise true will become false after adding the negate. It is similar to using the “!” symbol on a boolean.

Static

isEqual()

Returns a Predicate that tests whether two arguments are equal.

Java:

//Example of implementing a Predicate
public class hasAuth implements Predicate<String> {
    private static List<String> authList = Arrays.asList
("Bob", "Gina", "Clark", "Sam");

    @Override
    public boolean test(String name) {
        return authList.contains(name);
    }
}

Java Consumer Interface

The Consumer functional interface is different from the other functional interfaces because it has no return value. Consumer interfaces take at least one argument and perform an operation on them but do not return a result. It also has variations for primitive types as well as Bi-Consumer that takes an additional argument. Consumers are used frequently on collections such as in forEach which takes an implementation function but does not return a value. A Consumer has 2 built-in methods.

Abstract

accept()

Takes a parameter and performs an operation. This is the basic execution of a Consumer.

Default

andThen()

Takes a parameterized Consumer which is executed after the first Consumer.

Java:

//Example of implementing a Consumer by using a lambda expression
int[] total = {0};
listOfNums.forEach(num -> total[0] += num);

Java Supplier Interface

The Supplier functional interface is also different from the other functional interfaces because it has no arguments. Supplier interfaces take no arguments and return a result. Does not have variations because it does not take any arguments. Suppliers can be lazy loaded to process large amounts of data. Suppliers can use values outside of the function but they must be static. A common example of a supplier is writing a function to generate a factorial. The supplier only has one built in method.

Abstract

get()

Returns a result. This is the basic execution of a Supplier.

Java

//Example of inplementing Supplier using a lambda expression
int[] numbers = {0, 1};
Stream<Integer> fibonacci = Stream.generate(() -> {
    int result = numbers[1];
    int nextNum = numbers[0] + numbers[1];
    numbers[0] = numbers[1];
    numbers[1] = nextNum;
    return result;
});

Method Overriding In Java

Overriding a method in Java allows a subclass or child class to define a specific implementation of a method that exists in the parent class. Java has an @Override annotation that is good practice to use. The annotation allows the compiler to throw an error if the override is not correct. This is important as it is easy to accidentally misspell the method name. Beside the added check it does to your code, this also makes the program easier to read. Others can easily tell when they see the annotation that you are overriding that method.

In relation to functional interfaces overriding is essential. The abstract method that all interfaces have must be overridden when implementing a functional interface. Lambda expressions do this automatically, but in a subclass this must be defined. This not only applies to functional interfaces but all subclasses of a parent class with an abstract method or methods.

Default methods can also be overridden but it is not required. In this case the compiler will apply the specified implementation based on what object is called. So if the method is called from the subclass then the defined method for the overridden method will be used. However when the method is called from the parent class it will use the original implementation of the method.

Java

//Example of overriding an abstract method
public class saveEntity implements Consumer<Entity> {
    @Override
    public void accept(Entity entity) {
        //modify name to all upper case
        entity.setFirstName(entity.getFirstName().toUpperCase());
        entity.setLastName(entity.getLastName().toUpperCase());

        //save the entity
        entityRepository.save(entity);
    }
}

Conclusion

Functional interfaces are a tool in Java to help define behavior. When creating a function interface the @FunctionalInterface annotation should be used but is optional. When implementing a functional interface the abstract class , of which there can only be one, must be overridden. It is good practice to use the @Override annotation to ensure the method is overridden correctly. Lambda expressions are a powerful tool that can vastly simplify implementing function interfaces. Lambda expressions are similar to arrow functions in JavaScript. They can be implemented by using the “->” symbol(lambda expression) or the “::” symbol(method reference) if the Object already has a defined method.