Скачать или смотреть Understanding How a Supplier Works in Java with Lambda Expressions

Dive into the Java `Supplier` functional interface, clarifying how lambdas operate, default methods, and method overriding in a way that enhances your understanding of Java's functional programming capabilities.
---
This video is based on the question https://stackoverflow.com/q/68466703/ asked by the user 'Oskar Lund' ( https://stackoverflow.com/u/435860/ ) and on the answer https://stackoverflow.com/a/68466772/ provided by the user 'Joachim Sauer' ( https://stackoverflow.com/u/40342/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Java Supplier defined as lambda. Need help understanding how this code even runs

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding How a Supplier Works in Java with Lambda Expressions

Java has introduced a range of features aimed at embracing functional programming, and the Supplier is a key component of that. Sometimes, though, users can get confused about how to implement these interfaces, especially when they use lambdas. In this guide, we will break down a question regarding the Supplier interface and lambdas, and clarify how to utilize these components effectively.

The Problem

The crux of the issue centers around a developer's confusion about how their implementation of the SomeSupplier interface with a lambda expression works. Specifically, they were unsure about how the lambda could implement the Supplier.get() method while also providing its own method getSome() and maintaining a default implementation for get().

This confusion arises from the behavior of functional interfaces and lambda expressions in Java.

Here's a brief look at the code that sparked the question:

[[See Video to Reveal this Text or Code Snippet]]

The developer wanted to understand why this lambda expression does not override their SomeSupplier.getSome() method but instead aligns itself with an existing implementation of the get() method

The Solution

The misunderstanding stems from the way Java defines and implements functional interfaces, especially in the context of lambda expressions and default methods. Let’s break it down step-by-step.

Understanding Functional Interfaces

A functional interface is an interface that contains only one abstract method. Such interfaces can be implemented using lambda expressions, in which case the lambda automatically implements that single abstract method.

Key Points:

Functional interface: An interface with a single abstract method (e.g., Supplier has get()).

Lambda Expression: Allows the implementation of the functional interface in a concise way.

Why SomeSupplier Behaves Differently

In our case, the SomeSupplier interface extends the Supplier interface but also defines its own abstract method getSome(). However, it also implements a default method for get().

[[See Video to Reveal this Text or Code Snippet]]

Since this default method provides an implementation for get(), get() is no longer the single abstract method of SomeSupplier. Instead, getSome() now takes that role.

What Happens with the Lambda

When you write:

[[See Video to Reveal this Text or Code Snippet]]

This code effectively means "implement getSome() because get() has a default implementation." The underlying process is akin to the following:

[[See Video to Reveal this Text or Code Snippet]]

In this case:

The lambda is providing an implementation of getSome() rather than get(). This is why the implementation retains the get() behavior defined in the default method.

Summary of Key Takeaways

Only One Abstract Method: A functional interface like Supplier allows for only one abstract method. When extending, if a default implementation is provided, only the other custom methods become eligible for lambda implementation.

Lambdas Implement Abstract Methods: Lambdas always aim to implement the single abstract method in the target functional interface, not its parent interfaces.

Default Methods Matter: When a default method is defined, it can alter how subclasses and lambdas interact with the interface, thus affecting what is implemented in the lambda itself.

In conclusion, understanding how Java’s functional interfaces work, especially in the context of default methods and lambda expressions, can take some getting used to. However, once you grasp these principles, you'll find them immensely powerful in