Java Interface Basics

Questions and Answers

What keyword is used to declare an interface before Java 8?

class

interface (correct)

default

abstract

What is the purpose of default methods in Java 8 interfaces?

To add new methods to an interface without breaking existing implementations.

Java 9 allows public methods in interfaces.

False

All interface methods are implicitly ______ if the interface is declared public.

public Signup and view all the answers

Which statement about abstract classes and interfaces is false?

All of the methods in both an abstract class and an interface are public. Signup and view all the answers

What must a non-abstract class doing that implements an interface provide?

Concrete implementation of all abstract methods. Signup and view all the answers

In a default interface method, which keyword indicates that it can provide a method body?

default Signup and view all the answers

What does the example public class InterfaceExampleOne implements interfaceOne {} demonstrate?

A class implementing an interface. Signup and view all the answers

What is one rule for declaring interfaces in Java 8?

Methods can be static. Signup and view all the answers

Study Notes

Declaring an Interface (Before Java 8)

Interfaces are defined using the interface keyword.
Example structure includes variables and methods:
- int i=0;
- Methods like public void Height(int height); and public abstract void setHeight();

Java 8 Interface Enhancements

Introduction of Default Methods allows methods with bodies in interfaces.
Methods can use modifiers: "abstract", "static", or "default".
Default methods enable the addition of new methods without breaking existing implementations.

Importance of Default Methods

Default methods in interfaces are implicitly public, no need for explicit public modifier.
Facilitate adding methods to interfaces without forcing all implementations to adopt new methods.
Help maintain backward compatibility, preventing the need for extensive refactoring.

Java 9 Interface Features

Java 9 permits the inclusion of private methods in interfaces to enhance encapsulation.

Rules for Declaring Interfaces

Methods and variables in an interface are implicitly public if declared public.
All interface methods are implicitly public and abstract (pre-Java 8).
Interfaces can only declare constants (public static final variables).
Instance variables are banned; all interface variables are implicitly public, static, and final.
Interface methods cannot be static, final, strictfp, or native.
An interface can extend multiple other interfaces but cannot extend classes or implement other interfaces.

Abstract Classes vs. Interfaces

Statement E: "All methods in both an abstract class and an interface are public" is false.
- Interfaces have public methods by default, while abstract classes can contain private methods as well.

Rules for Declaring Interfaces (Java 8)

All interface methods can have "abstract", "static", or "default" modifiers.
Methods can contain bodies if marked as static or default.

Implementation Rules for Non-Abstract Classes

Non-abstract classes implementing an interface must provide concrete implementations for all abstract methods.
Must adhere to overriding rules, maintaining method signature accuracy.

Class Implementing an Interface Example

Basic structure:

public class InterfaceExampleOne implements interfaceOne {
}

interface interfaceOne {
}

Default Interface Methods Functionality

Example of Vehicle interface demonstrating default methods:

public interface Vehicle {
    String getBrand();
    String speedUp();
    String slowDown();
    default String turnAlarmOn() {
        return "Turning the vehicle alarm on.";
    }
    default String turnAlarmOff() {
        return "Turning the vehicle alarm off.";
    }
}

Default methods enhance functionality while facilitating legacy support within interfaces.

Description

Explore the fundamentals of declaring and using interfaces in Java, including features introduced in Java 8. This quiz will test your understanding of traditional and modern approaches to interfaces, including default methods.