interface / implements / abstract

// Define an interface.
interface InterfaceName {
    // Abstract method (no implementation)
    ReturnType methodName(args);

    // default method (Java 8+, has a default implementation)
    default ReturnType methodName(args) {
        // Default logic
    }

    // static method (Java 8+)
    static ReturnType methodName(args) {
        // Logic
    }
}

// Implement an interface (multiple interfaces allowed).
class MyClass implements InterfaceA, InterfaceB {
    @Override
    public ReturnType methodName(args) {
        // Implementation
    }
}

// Define an abstract class.
abstract class AbstractClass {
    // Abstract method (must be implemented by subclasses)
    abstract ReturnType methodName(args);

    // Concrete method (shared logic)
    void commonMethod() {
        // Logic
    }
}

// Define the Drawable interface.
interface Drawable {
    void draw(); // Abstract method

    default String getType() { // Default method
        return "Shape";
    }
}

// Partially implement Drawable with an abstract class.
abstract class Shape implements Drawable {
    String color;

    Shape(String color) {
        this.color = color;
    }

    // draw() remains abstract, leaving the implementation to subclasses.
    @Override
    public abstract void draw();
}

// Implement the abstract method in a concrete class.
class Circle extends Shape {
    double radius;

    Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drew a " + color + " circle (radius: " + radius + ").");
    }
}

Drawable d = new Circle("red", 5.0);
d.draw();        // Prints: "Drew a red circle (radius: 5.0)."
System.out.println(d.getType()); // Prints: "Shape"

// Implement multiple interfaces.
interface Resizable {
    void resize(double factor);
}

class Square extends Shape implements Resizable {
    double side;

    Square(String color, double side) { super(color); this.side = side; }

    @Override public void draw() { System.out.println("Drew a " + color + " square."); }
    @Override public void resize(double factor) { side *= factor; }
}

An interface defines a contract for what a class "can do," and a class can implement multiple interfaces. An abstract class provides shared implementation while delegating specific behavior to its subclasses. A class can only extend one abstract class (single inheritance), but it can implement multiple interfaces at the same time.

Since Java 8, interfaces can define default methods, which blurs the distinction between interfaces and abstract classes. Use an abstract class when you need shared state (fields) and common logic; use an interface when you only need to define a type contract.

For inheritance basics, see extends / super / @Override. For functional interfaces, see Predicate / Function / Consumer / Supplier.