# Defining Interfaces

How to write a Java interface and implement more than one in a class with the \`implements\` keyword.

Journeyman · Java · OOP · Updated November 16, 2026

By Gregor Dzierzon

Interfaces are created like abstract classes are, with a few minor differences.

- You don't write the `abstract` keyword: a method in an interface with no body is abstract automatically
- You don't declare a method's visibility: methods in an interface are public automatically

Following are the definitions of the interfaces described earlier. Notice that there are no method bodies for any of the methods.

```java
public interface Drivable
{
    void turnOn();
}
```

```java
public interface BladeController
{
    int getBladeSpeed();
    void setBladeSpeed(int speed);

    void turnOn();
}
```

To implement an interface, we use the implements keyword, and then use a comma separated list of all interfaces we want to use.

We must write method implementations for all methods defined by the interfaces.

This class implements both interfaces:

```java
public class RidingMower implements Drivable, BladeController
{
    private String make;
    private String model;
    private int bladeSpeed;

    public RidingMower(String make, String model, int bladeSpeed)
    {
      this.make = make;
      this.model = model;
      this.bladeSpeed = bladeSpeed;
    }

    // this overrides both Drivable AND BladeController
    @Override
    public void turnOn()
    {
      System.out.println(make + " has been turned on");
    }

    @Override
    public int getBladeSpeed()
    {
      return bladeSpeed;
    }

    @Override
    public void setBladeSpeed(int speed)
    {
      bladeSpeed = speed;
    }

}
```

## Do it: give the mower a fuel tank

The shop's riding mower needs a fuel gauge, and its tractors and leaf blowers will need one later. So write the contract first, as an interface, and then have `RidingMower` keep it.

`RidingMower` is started, with its make and model.

The contract, an interface named `FuelTank`, has two methods:

- `int getFuel()`: how many liters are in the tank.
- `void addFuel(int liters)`: pours `liters` more into the tank.

The tank holds at most `10` liters. A new mower's tank is empty.

For example:

```java
FuelTank tank = new RidingMower("Meadow Pro", "5500");
tank.addFuel(5);
tank.addFuel(3);
```

| Step | Fuel |
|---|---|
| A new mower | `0` |
| `addFuel(5)` | 0 + 5 = `5` |
| `addFuel(3)` | 5 + 3 = `8` |

So after those two calls, `tank.getFuel()` returns `8`.

**Your job:** write the interface, then keep it in `RidingMower`.

- Write the interface `FuelTank` with the two methods above, with no bodies.
- Make `RidingMower` implement `FuelTank`.
- Give `RidingMower` a field for its fuel, starting at `0`, and write the two methods.
- When more fuel is poured than fits, the tank fills to `10` and the rest spills: `8` liters, then `addFuel(5)`, makes `10`, not `13`.

Practiced live on the lesson page: write the Java right there and check it.

## Cheat sheets

- [Defining Interfaces](https://www.ask-codey.com/cheat-sheets/defining-interfaces-cheat-sheet)

Source: https://www.ask-codey.com/lessons/defining-interfaces
