DZone
Java Zone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
  • Refcardz
  • Trend Reports
  • Webinars
  • Zones
  • |
    • Agile
    • AI
    • Big Data
    • Cloud
    • Database
    • DevOps
    • Integration
    • IoT
    • Java
    • Microservices
    • Open Source
    • Performance
    • Security
    • Web Dev
DZone > Java Zone > Java 8 — Functional Interfaces (SAM)

Java 8 — Functional Interfaces (SAM)

Going in depth with Java 8's concept of functional interfaces, and how that affects classes and objects.

Hari Kiran G user avatar by
Hari Kiran G
·
Apr. 07, 16 · Java Zone · Tutorial
Like (27)
Save
Tweet
43.53K Views

Join the DZone community and get the full member experience.

Join For Free

There are numerous interfaces in the Java library that declare a single abstract method; few such interfaces include:

// in java.lang package
interface Runnable { void run(); }

// in java.util package
interface Comparator<T> { boolean compare(T x, T y); }

// java.awt.event package:
interface ActionListener { void actionPerformed(ActionEvent e); }

// java.io package
interface FileFilter { boolean accept(File pathName); }

Java 8 has introduced the concept of “functional interfaces” that formalizes this idea. A functional interface specifies only one abstract method. Since functional interfaces specify only one abstract method, they are sometimes known as Single Abstract Method (SAM) types or interfaces.

Note: Functional interfaces can take generic parameters, as in the Comparator<T> and Callable<T> interfaces in the above examples.

For an interface to be treated as a functional interface, it should have only one abstract method. However, it may have any number of default or static methods defined in it. Let us see an example from the Java library to understand this.

Here is the definition of java.util.function.IntConsumer interface (without annotations and javadoc comments):

public interface IntConsumer {
  void accept(int value);
  default IntConsumer andThen(IntConsumer after) {
Objects.requireNonNull(after);
return (int t) -> { accept(t); after.accept(t); };
  }
}

Though this interface has two members, andThen method is a default method and only accept method is an abstract method. Hence, IntConsumer interface is a functional interface.

@FunctionalInterface Annotation

The Java compiler infers any interface with a single abstract method to be a functional interface. However, you can tag functional interface with @FunctionalInterface annotation to affirm that. It is a recommended practice to provide @FunctionalInterface to functional interfaces because the compiler can give better errors/warnings when you have this annotation.

Here is an example of using @FunctionalInterface that has one abstract method, so it will compile cleanly:

@FunctionalInterface
public interface AnnotationTest {
int foo();
}

How about this one?

@FunctionalInterface
public interface AnnotationTest {
default int foo() {};
}

It results in a compiler error “no abstract method found in interface” because it only has a default method provided but does not have any abstract methods. 

Methods From Object Class in Functional Interfaces

According to the Java Language Specification (version 8.0), “interfaces do not inherit from Object, but rather implicitly declare many of the same methods as Object.” If you provide an abstract method from Object class in the interface, it still remains a functional interface.

For example, consider the Comparator interface that declares two abstract methods:

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
    // other methods are default methods or static methods and are elided
}

This interface is a functional interface, though it declares two abstract methods: compare() and equals() methods. How is it a functional interface when it has two abstract methods? Because equals() method signature matches from Object, and the compare() method is the only remaining abstract method, hence the Comparator interface is a functional interface.

How about this interface definition?

@FunctionalInterface
interface EqualsInterface {
   boolean equals(Object obj);
}

The compiler gives the error: “EqualsInterface is not a functional interface: no abstract method found in interface EqualsInterface”. Why? Since the method equals is from Object, it is not considered as a functional interface. Check out this book for more learning about functional interfaces. You can download the source code here

Interface (computing) Java (programming language)

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • Your Old Laptop Is Your New Database Server
  • Password Authentication: How to Correctly Do It
  • How to Generate Fake Test Data
  • Java Hashtable, HashMap, ConcurrentHashMap: Performance Impact

Comments

Java Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • MVB Program
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends:

DZone.com is powered by 

AnswerHub logo