Interfaces and Higher-Level Abstractions

Starter: think before typing

Before running this abstraction example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Your build passed.`; predict how the focus line helps produce that evidence.

Learning Objectives

• Define a Java interface.
• Use polymorphism through interface references.
• Explain dependency on behaviour rather than concrete classes.
• Design a swappable component.

Learning Outcomes

• By the end of the lesson, you can define a Java interface.
• By the end of the lesson, you can use polymorphism through interface references.
• By the end of the lesson, you can explain dependency on behaviour rather than concrete classes.
• By the end of the lesson, you can design a swappable component.

Why this idea exists

Interfaces express one of programming's most powerful ideas: depend on what something can do, not exactly what concrete thing it is. This supports substitution, testing and flexible design.

This style developed from broader abstraction principles in software engineering. As systems grew, programmers needed ways to reduce coupling so one implementation could change without forcing changes everywhere.

In Java, an interface is a contract. Used well, it lets a program talk to a capability such as notification, storage or scoring without caring whether the implementation uses email, a file, a database or a mock object.

Deep dive

Lesson visual

Type this and run it

Create InterfacesAndHigherAbstractionsDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

public class InterfacesAndHigherAbstractionsDemo {
  public static void main(String[] args) {
    Notifier notifier = new ConsoleNotifier();
    notifier.send("Your build passed.");
  }
}

interface Notifier {
  void send(String message);
}

class ConsoleNotifier implements Notifier {
  public void send(String message) {
    System.out.println(message);
  }
}

Build and run it with:

javac InterfacesAndHigherAbstractionsDemo.java && java InterfacesAndHigherAbstractionsDemo

Expected baseline: Your build passed.

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is Notifier notifier = new ConsoleNotifier();; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in interfaces and higher-level abstractions is treating the example as a finished answer. For abstraction, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

How to study this lesson

For Interfaces and Higher-Level Abstractions, predict how abstraction changes the run before you press Run.

Use the first portfolio task as your main edit: Create a Notifier interface.

Use the second task as your variation: Write two implementations.

Finish with evidence, not a diary entry: Use the interface in a service class.

Portfolio Practice

1. Create a Notifier interface.
2. Write two implementations.
3. Use the interface in a service class.

Final self-check

Study route

Practise abstraction by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Exceptions and Defensive Programming and carry forward one improvement from this lesson into the next program.