Introduction to Functional Interfaces – A concept recreated in Java 8

Any java developer around the world would have used at least one of the following interfaces: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. There is some common feature among the stated interfaces and that feature is they have only one method declared in their interface definition. There are lot more such interfaces in JDK and also lot more created by java developers. These interfaces are also called Single Abstract Method interfaces (SAM Interfaces). And a popular way in which these are used is by creating Anonymous Inner classes using these interfaces, something like:
 
 
 

public class AnonymousInnerClassTest {
  public static void main(String[] args) {
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println('A thread created and running ...');
      }
    }).start();
  }
}

With Java 8 the same concept of SAM interfaces is recreated and are called Functional interfaces. These can be represented using Lambda expressions, Method reference and constructor references(I will cover these two topics in the upcoming blog posts). There’s an annotation introduced- @FunctionalInterface which can be used for compiler level errors when the interface you have annotated is not a valid Functional Interface. Lets try to have a look at a simple functional interface with only one abstract method:

@FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
}

The interface can also declare the abstract methods from the java.lang.Object class, but still the interface can be called as a Functional Interface:

@FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
  public String toString();
  public boolean equals(Object o);
}

Once you add another abstract method to the interface then the compiler/IDE will flag it as an error as shown in the screenshot below:

Functional Interface Error

Interface can extend another interface and in case the Interface it is extending in functional and it doesn’t declare any new abstract methods then the new interface is also functional. But an interface can have one abstract method and any number of default methods and the interface would still be called an functional interface. To get an idea of default methods please read here.

@FunctionalInterface
public interface ComplexFunctionalInterface extends SimpleFuncInterface {
  default public void doSomeWork(){
    System.out.println('Doing some work in interface impl...');
  }
  default public void doSomeOtherWork(){
    System.out.println('Doing some other work in interface impl...');
  }
}

The above interface is still a valid functional interface. Now lets see how we can use the lambda expression as against anonymous inner class for implementing functional interfaces:

/*
* Implementing the interface by creating an
* anonymous inner class versus using 
* lambda expression.
*/
public class SimpleFunInterfaceTest {
  public static void main(String[] args) {
    carryOutWork(new SimpleFuncInterface() {
      @Override
      public void doWork() {
        System.out.println('Do work in SimpleFun impl...');
      }
    });
    carryOutWork(() -> System.out.println('Do work in lambda exp impl...'));
  }
  public static void carryOutWork(SimpleFuncInterface sfi){
    sfi.doWork();
  }
}

And the output would be …

Do work in SimpleFun impl...
Do work in lambda exp impl...

In case you are using an IDE which supports the Java Lambda expression syntax(Netbeans 8 Nightly builds) then it provides an hint when you use an anonymous inner class as used above:

Functional Interface Hint
This was a brief introduction to the concept of functional interfaces in java 8 and also how they can be implemented using Lambda expressions.
 

Reference: Introduction to Functional Interfaces – A concept recreated in Java 8 from our JCG partner Mohamed Sanaulla at the Experiences Unlimited blog.

Related Whitepaper:

Bulletproof Java Code: A Practical Strategy for Developing Functional, Reliable, and Secure Java Code

Use Java? If you do, you know that Java software can be used to drive application logic of Web services or Web applications. Perhaps you use it for desktop applications? Or, embedded devices? Whatever your use of Java code, functional errors are the enemy!

To combat this enemy, your team might already perform functional testing. Even so, you're taking significant risks if you have not yet implemented a comprehensive team-wide quality management strategy. Such a strategy alleviates reliability, security, and performance problems to ensure that your code is free of functionality errors.Read this article to learn about this simple four-step strategy that is proven to make Java code more reliable, more secure, and easier to maintain.

Get it Now!  

Leave a Reply


one × = 7



Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.

Sign up for our Newsletter

15,153 insiders are already enjoying weekly updates and complimentary whitepapers! Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

As an extra bonus, by joining you will get our brand new e-books, published by Java Code Geeks and their JCG partners for your reading pleasure! Enter your info and stay on top of things,

  • Fresh trends
  • Cases and examples
  • Research and insights
  • Two complimentary e-books