Lesson 17 • Advanced
Interfaces & Abstraction Best Practices
Default methods, sealed interfaces, and interface-first design principles.
📚 Before You Start
You should be comfortable with:
- Interfaces & Abstract Classes (Lesson 11) — basic contracts
- Inheritance (Lesson 10) — extends, polymorphism
- Design Patterns (Lesson 16) — Factory, Decorator patterns
What You'll Learn
- ✅ Default methods in interfaces (Java 8+)
- ✅ Static methods in interfaces
- ✅ Private methods in interfaces (Java 9+)
- ✅ Sealed interfaces (Java 17+)
- ✅ Interface vs abstract class decision guide
- ✅ Interface-first (contract-first) design
1️⃣ Interface Evolution in Java
💡 Analogy: USB Standards — An interface is like a USB standard. Any device that follows the spec can plug in. Default methods are like backwards-compatible upgrades — USB-C added features while old devices still work. Sealed interfaces restrict which connector types are allowed.
The Diamond Problem: When a class implements two interfaces with the same default method, Java forces you to override it explicitly — ensuring no ambiguity.
2️⃣ Sealed Interfaces (Java 17+)
Sealed interfaces restrict which classes can implement them using the permits clause. This enables exhaustive pattern matching in switch expressions.
public sealed interface Shape permits Circle, Rectangle, Triangle {
double area();
}
// Compiler guarantees all cases handled
double describe(Shape s) {
return switch (s) {
case Circle c -> Math.PI * c.radius() * c.radius();
case Rectangle r -> r.width() * r.height();
case Triangle t -> 0.5 * t.base() * t.height();
}; // No default needed!
}Try It: Default Methods & Multiple Interfaces
See how default methods enable backward-compatible API evolution
// 💡 Try modifying this code and see what happens!
// Default Methods & Multiple Interfaces (Simulated)
console.log("=== Default Methods ===\n");
// Interface with default method
class Printable {
toString() { throw new Error("Must implement toString()"); }
printFormatted() {
console.log(" [Formatted] " + this.toString());
}
}
class Product extends Printable {
constructor(name, price) { super(); this.name = name; this.price = price; }
toString() { return this.name
...3️⃣ Contract-First Design
The principle: "Program to an interface, not an implementation." Define what your code does before deciding how it does it. This makes swapping implementations trivial.
// ✅ Good: Code depends on interface List<String> names = new ArrayList<>(); // can swap to LinkedList // ❌ Bad: Code depends on implementation ArrayList<String> names = new ArrayList<>(); // locked in
Try It: Contract-First Payment System
Build a payment system where implementations can be swapped freely
// 💡 Try modifying this code and see what happens!
// Contract-First Design (Simulated)
console.log("=== Contract-First Design ===\n");
// Define the contract (interface)
// PaymentProcessor must have: processPayment, refund, getBalance
class StripeProcessor {
constructor() { this.balance = 1000; this.name = "Stripe"; }
processPayment(amount) {
this.balance -= amount;
return { id: "stripe_" + Date.now(), amount, provider: this.name };
}
refund(txnId) { console.
...4️⃣ Abstract Class vs Interface Comparison
| Feature | Interface | Abstract Class |
|---|---|---|
| Multiple inherit | ✅ Yes | ❌ No |
| Constructor | ❌ No | ✅ Yes |
| State (fields) | constants only | ✅ Yes |
| Default methods | ✅ Yes (Java 8+) | ✅ Yes |
| Access modifiers | public only | any modifier |
Decision rule: "Can do" → Interface. "Is a" → Abstract class. When in doubt → Interface.
Try It: Sealed Interface Pattern Matching
Simulate sealed interfaces with exhaustive pattern matching
// 💡 Try modifying this code and see what happens!
// Sealed Interfaces (Simulated)
console.log("=== Sealed Interface Simulation ===\n");
// Simulating sealed interface Shape permits Circle, Rectangle, Triangle
class Circle {
constructor(radius) { this.radius = radius; this.type = "Circle"; }
area() { return Math.PI * this.radius * this.radius; }
}
class Rectangle {
constructor(w, h) { this.w = w; this.h = h; this.type = "Rectangle"; }
area() { return this.w * this.h; }
}
cla
...5️⃣ Common Mistakes
6️⃣ Pro Tips
💡 Program to an interface, not an implementation — use List<String>, not ArrayList<String>.
💡 Sealed interfaces + records = algebraic data types in Java for functional-style pattern matching.
💡 Decision rule: "Can do" → Interface. "Is a" → Abstract class.
📋 Quick Reference
| Feature | Syntax | Since |
|---|---|---|
| Default method | default void m() {} | Java 8 |
| Static method | static void m() {} | Java 8 |
| Private method | private void m() {} | Java 9 |
| Sealed interface | sealed interface permits A, B | Java 17 |
| Functional interface | @FunctionalInterface | Java 8 |
🎉 Lesson Complete!
You now understand modern interface design including default methods, sealed types, and contract-first architecture!
Next: Inner Classes & Anonymous Classes — static, non-static, local, and anonymous inner classes.
Sign up for free to track which lessons you've completed and get learning reminders.