Gain insights into Java 8's new features: lambdas, Stream API, Functional Interfaces, Collections improvements, Memory Management, and Date & Time API to enhance productivity and code quality.

Java 8 has introduced a ton of features and enhancements to boost developer productivity, while making your code faster, more concise, and more readable. 
In this course, you will learn about lambdas, Java Stream API, Functional Interfaces, as well as lots of other new improvements related to Collections, Memory Management, Date & Time API. 
After completing this course, you’ll be well versed in all the functionality of Java 8 and be ready to utilize these new features in your own code.

Java 8 for Experienced Developers: Lambdas, Stream API & Beyond

# What are functional interfaces?
An interface that has a single abstract method is called a functional interface. 

While an interface can have one or more default methods, it should have only one abstract method to be called a functional interface.

Java 8 has defined the `java.util.function` package, containing lots of functional interfaces. Some of the functional interfaces defined in Java 8 are `Predicate`, `Consumer`, `Supplier`, `Function`, etc.

The functional interface is used by lambda expressions. In the next chapter, we will discuss lambdas and also see the usage of some of the functional interfaces in Java 8.


  
# What is `@FunctionalInterface` annotation?
Any interface that has only one abstract method can be annotated with the `@FunctionalInterface` annotation. 

This is not mandatory but if an interface is annotated with `@FunctionalInterface` annotation and someone tries to add another abstract method to the interface, then the compiler will throw an error.
Below is an example of a functional interface.

@FunctionalInterface
public interface Functional {
    void doSomething();

    default void foo() {
        System.out.println("foo");
    }
}


If we try to add one more abstract method in the above interface, the compiler shows an error. If an interface is annotated with `@FunctionalInterface` annotation but does not contain even a single abstract method, then also the compiler will complain.

Is it necessary to declare a functional interface with `@FunctionalInterface` annotation?

Is it necessary to declare a functional interface with <code>@FunctionalInterface</code> annotation?

Is it possible to override a static method declared in an interface?

Is it possible to override a static method declared in an interface?

We will need to override the method in our class.

What would happen if a class inherits two interfaces that, both have default methods with the same name? Select all that apply.

What would happen if a class inherits two interfaces that, both have default methods with the same name? Select all that apply.

---
That is all about interfaces for now. In the next chapter, we will start exploring lambdas.

This lesson explains the concept of functional interfaces which were introduced in Java 8.

Let's Begin

Taste of lambdas

Stream API

Java 8 Collections Improvements

Java 8 Concurrency API Improvements

Java Time API

Conclusion

Functional Interfaces in Java

What are functional interfaces?

What is `@FunctionalInterface` annotation?