Interfaces: Job Interviews for Your Classes

This week, we're diving into the elegant, expectation heavy world of interfaces in Java. If you thought classes were demanding, wait until you meet interfaces. They're like job interviewers: they don’t care what you’ve done before, they just want to know if you implement the right methods.

And yes, I know I teased abstraction last week, but let’s be honest, this blog got intercepted by an interface halfway through and demanded I implement this one first. So, here we are.

---

What Even Is an Interface?

An interface in Java is basically a contract. It says: “If you're going to be this kind of thing, then you must do these things.” It's like your class saying, "Sure, I can be printable," and then Java going, "Prove it. Write the print() method."

Interfaces don't care how you do something, they just demand that you do it. No explanations. No excuses. Just methods.

---

Real World Analogy: The Interview Panel

Think of an interface like a job description. When your class 'applies' for the job (implements the interface), it has to promise that it can do every task listed in that job spec.

For example:

java
public interface Employable {
    void submitCV();
    void attendInterview();
    void drinkNervousWater();
}

public class JuniorDev implements Employable {
    public void submitCV() {
        System.out.println("CV submitted in Comic Sans");
    }
    public void attendInterview() {
        System.out.println("Nailed it. Sweated slightly");
    }
    public void drinkNervousWater() {
        System.out.println("Accidentally spilled it on the interviewer");
    }
}

---

How I Used It in My Assignment

In my Media Diary project, I created a Comparer interface to define how different comparison strategies could be plugged in. One implementation (CompareByPurpose) looked at how much time users spent on educational media. That interface basically said, “Hey class, can you compare stuff?” and the class replied, “Absolutely. Hold my curly braces.”

Why Interfaces Are Useful

• Flexible design: Classes can implement multiple interfaces. It’s Java’s way of letting you have more than one personality, officially.
• Decoupling: You can write code that relies on the interface without knowing the exact class. It’s like trusting someone to cook without knowing whether they use gas or induction.

Quick Notes

• Interfaces can't have method bodies (unless you're using default methods, but let’s save that rabbit hole for another post).
• A class can implement many interfaces.
• Think of them as the opposite of clingy: interfaces tell you what they want, but never how to do it.

Final Thoughts

Interfaces are that polite yet persistent part of Java that remind you to keep your promises. You say you can compare? You’d better write that method. You say you can fly? Better implement takeOff().

Next time: abstraction, the mysterious concept that only shows you the surface, like a duck gliding calmly while paddling like mad underneath.

Until then, keep your methods public, your classes clean, and your nervous water far from the keyboard.