Question

Fill in the blanks in each of the following statements: a) In Java SE 8 , an interface may declare ______ that is, public methods with concrete implementations that specify how an operation should be performed. b) As of Java SE 8 , interfaces can now include ______ helper methods. c) As of Java SE 8 , any interface containing only one method is known as a(n) ______

Short answer

a) default methods b) static methods c) Functional Interface

Step-by-step solution

Identify Java SE 8 Interface Features

Java SE 8 introduced default and static methods in interfaces. Default methods are public methods with concrete implementations in an interface. Static methods are utility or helper methods that can be defined in interfaces.

Complete Statement a)

For statement a), recall that interfaces in Java SE 8 can have implemented methods that are not abstract. These methods allow developers to add new methods to interfaces without breaking existing implementations. They are known as default methods.

Complete Statement b)

For statement b), Java SE 8 allows interfaces to have static methods. Static methods are not part of the instance of a class but are instead methods that can be called on the interface itself. They are known as static methods.

Complete Statement c)

For statement c), remember that an interface with only one abstract method has a special name in Java SE 8. This type of interface is used as the basis for lambda expressions. Such an interface is known as a Functional Interface.

Key concepts

Default Methods in Java Interfaces

With the advent of Java SE 8, the ability to create default methods within interfaces revolutionized the way Java developers could evolve their software. A default method is a public method inside an interface that comes with a concrete implementation. This means that even though a class may not provide its own implementation for such methods, it can still benefit from the logic provided by the interface.

Consider the common scenario where an API needs to introduce new functionality without disrupting existing implementations. By using default methods, new behaviors can be added, and all the implementing classes will inherit these without requiring any changes. For instance:

• If you have an interface Vehicle, you could provide a default implementation for a new method startEngine(), ensuring that all types of vehicles have a basic way to start without needing to change every single implementation.

This feature significantly enhances interface flexibility, promoting backward compatibility and reducing the likelihood of code breakage when interfaces evolve.

Static Methods in Java Interfaces

Another significant feature introduced in Java SE 8 is the inclusion of static methods in interfaces. These static methods are akin to static methods within classes; they are not associated with an instance of a class but belong to the interface itself.

These utility or helper methods can be invoked without creating an instance of a class that implements the interface, thus serving as a convenient place for shared logic. For instance:

• In a MathOperations interface, you could define static methods like add(), subtract(), or multiply() and call them without needing an object, simplifying syntax like MathOperations.add(3, 5) to perform operations directly through the interface.

Static methods help in organizing utility functions under relevant interfaces, aiding in maintaining a clean code structure and enhancing code reuse.

Functional Interfaces in Java

The concept of a functional interface is a cornerstone of lambda expression support, introduced in Java SE 8. A functional interface is an interface that is intended to have exactly one abstract method.

This single abstract method serves as the target for lambda expressions and method references. In essence, a functional interface becomes a blueprint for creating instances that implement this single method, allowing succinct code that focuses on the method's logic. For example:

• An interface Compute with a single method int calculate(int a, int b) can be implemented on-the-fly with a lambda like (a, b) -> a + b, making it straightforward to pass around behavior as if it were data.

While a functional interface may contain other methods, such as default or static methods, the key is that there is only one abstract method that defines the functional aspect of the interface. The @FunctionalInterface annotation, while not required, is a helpful way to indicate the purpose of the interface and enables compile-time checking to ensure its contract isn't accidentally broken by adding additional abstract methods.