1.2.6 Interfaces Explained

Interfaces are a fundamental concept in Java that allow you to define a contract for classes to follow. They specify a set of methods that a class must implement, without providing any implementation details. Understanding interfaces is crucial for mastering Java SE 11.

Key Concepts

1. Definition and Purpose

An interface is a collection of abstract methods and constants. It defines what a class should do, but not how it should do it. Interfaces are used to achieve abstraction and multiple inheritance in Java. They are like a blueprint that outlines the required methods, but leaves the implementation to the implementing class.

2. Abstract Methods

Abstract methods are methods declared in an interface without an implementation. Any class that implements the interface must provide an implementation for these methods. Abstract methods are defined using the abstract keyword and do not have a method body.

3. Default Methods

Default methods are methods in an interface that have a default implementation. They allow you to add new functionality to existing interfaces without breaking the classes that already implement them. Default methods are defined using the default keyword and have a method body.

4. Static Methods

Static methods are methods in an interface that belong to the interface itself, not to any particular instance of the interface. They can be called using the interface name. Static methods are defined using the static keyword and have a method body.

5. Multiple Inheritance

Java does not support multiple inheritance of classes, but it does support multiple inheritance of interfaces. A class can implement multiple interfaces, thereby inheriting the abstract methods from all of them. This allows for greater flexibility and modularity in design.

Examples and Analogies

Consider an interface named Vehicle:

        public interface Vehicle {
            void start();
            void stop();
            
            default void honk() {
                System.out.println("Honk honk!");
            }
            
            static void displayInfo() {
                System.out.println("This is a vehicle interface.");
            }
        }
    

In this example, Vehicle is an interface with two abstract methods (start() and stop()), one default method (honk()), and one static method (displayInfo()).

Now, let's create a class that implements the Vehicle interface:

        public class Car implements Vehicle {
            @Override
            public void start() {
                System.out.println("The car is starting.");
            }
            
            @Override
            public void stop() {
                System.out.println("The car is stopping.");
            }
        }
    

In this example, the Car class implements the Vehicle interface and provides implementations for the start() and stop() methods. It also inherits the default honk() method and can call the static displayInfo() method using the interface name.

Think of an interface as a contract between a service provider and a service user. The contract specifies what services are available, but not how they are provided. For example, a car rental service might have a contract that specifies the services (start, stop, honk) that all cars must provide, but leaves the implementation details (how the car starts, stops, honks) to each individual car model.

By understanding interfaces, you can create more flexible and modular Java applications, making it easier to extend and maintain your code.