5910 Breckenridge Pkwy Suite B, Tampa, FL. 33610
(800) 272-0707

SkillSoft Explore Course

IT Professional Curricula     Software Development Solution Area     Java 2 Programming     Nested Classes and Lambda Expressions
Lambda expressions allow you to define classes that implement single-method interfaces in a very concise and compact manner. This makes code that uses lambda functions easier to read and understand and much more maintainable. Lambda expressions can be made even more compact and readable by the use of method references.
In this course, you will learn to create and use lambda expressions to implement functional interfaces. You will see that lambda expressions are essentially blocks of code that accept input arguments, perform operations, and return values.
Lambda expressions can be used in any place where we use anonymous classes or a named class that implements an interface with just a single abstract method. You will see that lambdas can only be used to implement functional interfaces i.e. interfaces that have exactly one abstract method. Such interfaces are usually annotated using the @FunctionalInterface annotation which allows the compiler to detect if the single abstract method contract has been violated for such interfaces. You will understand and implement the four types or categories of functional interfaces, the Predicate, Function, Consumer, and Supplier interfaces.
Finally, you will round this course off by exploring and implement method references which are essentially even more compact representations of lambda expressions.
When you are finished with this course you will have the skills and knowledge to construct lambda expressions in the right way and use Predicates, Functions, Suppliers, and Consumers to process and store your objects.

Objectives

Classes in Java: Implementing Functional Interfaces Using Lambdas

  • discover the key concepts covered in this course
  • define and use lambda expressions
  • compare and contrast lambda statements and expressions
  • recall how lambdas can only implement functional interfaces
  • implement interfaces with generic types using lambdas
  • mark functional interfaces with @FunctionalInterface annotation
  • recall how functional interface instances are objects
  • create Predicate, Consumer, Function, and Supplier interfaces
  • invoke static and instance methods using method references
  • invoke instance methods with types and invoke constructors using method references
  • summarize the key concepts covered in this course