Introduction
An Interface which has only one abstract method (SAM: Single Abstract Method) is called Functional Interface. It is used annotation @FunctionalInterface: An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification. Conceptually, a functional interface has exactly one abstract method. Since default methods have an implementation, they are not abstract. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.

Runnable, ActionListener, Comparable, Comparator, Callable Are some of the examples of functional interface. There is no need to use the abstract Keyword as it is optional to use the interface
why use Functional Interface?

It is used for enabling functional programming to java language. Functional Interface is also used for defining Lambda Expressions to Pass a function directly as argument to method.

Some Other Functional Interfaces

• Consumer Interface
• Predicate Interface 
• Marker Interfaces

Consumer Interface:  Consumer interface has no return value it returns nothing. there are functional variables of the consumer -DoubleConsumer, IntConsumer and LongConsumer. These variables accept primitives values as arguments.
package com.a143mk.SpringBoot.interfaces; import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; public class ConsumerInterfaceExample { static void addList(List<Integer> list){ // Return sum of list values int result = list.stream().mapToInt(Integer::intValue).sum(); //The Integer class wraps a value of the primitive type int in an object. An object of //type Integercontains a single field whose type is int. //:: is used for Direct Call method intValue. System.out.println("Sum of list values: "+result); } public static void main(String[] args) { // Creating a list and adding values List<Integer> list = new ArrayList<Integer>(); list.add(10); list.add(20); list.add(30); list.add(40); // Referring method to String type Consumer interface Consumer<List<Integer>> consumer = ConsumerInterfaceExample::addList; // :: is used for Direct Call method. consumer.accept(list); // Calling Consumer method Consumer<String> print = x -> System.out.println(x); print.accept("javaA143mk"); // java } }
Predicate Interface : it is a functional interface whose functional method is test(obj), that takes an argument and return boolean value.
package com.a143mk.SpringBoot.interfaces; import java.util.function.Predicate; public class Java8PredicatImpl { public static void main(String[] args) { Predicate<Integer> pr = a -> (a > 18); // Creating predicate System.out.println(pr.test(10)); // Calling Predicate method } }
The predicate functionl interface can also be implemented using a class.

Marker Interfaces: Marker Interface is an empity interface (no field or argument).
Marker Interface are serializable, cloneable and remote interface. All these interfaces are empity interfae.
package com.a143mk.SpringBoot.interfaces; //car marker interface interface Car { } //Engine marker interface interface Engine { } //class that implements the Car marker interface class Vehicle implements Car { static void isVehicle() { System.out.println("Car is a vehicle."); } } //class that implements the Engine marker interface class Status implements Engine { static void isWorking() { System.out.println("Yes, engine is working."); } } //main class public class A134mkMarkeInterface { public static void main(String args[]) { //invoking the methods of the class Vehicle.isVehicle(); Status.isWorking(); } }