Java Interface — Declaration, implements, default Methods & Best Practices
Everything you need to know about Java Interfaces — interface declaration, implementing interfaces, default/static/private methods, functional interfaces, marker interfaces, interface vs abstract class, sealed interfaces (Java 17+), anti-patterns, and real-world production code examples.
Last Updated
March 2026
Read Time
28 min
Level
Beginner to Intermediate
Chapter
20 of 35
What is an Interface in Java?
An interface in Java is a reference type — similar to a class — that defines a contract: a set of method signatures that any implementing class must honour. An interface specifies WHAT must be done, without prescribing HOW. It is the purest expression of abstraction in Java — separating the definition of a capability from any specific implementation of that capability.
Think of an interface as a legal contract. The interface says: 'Any class that signs this contract agrees to provide these methods.' A Printable interface contract says every implementing class will provide a print() method. A Comparable contract says every implementing class will provide a compareTo() method. The interface does not care how — only that the method exists and is callable.
Interfaces have evolved significantly across Java versions. In Java 7 and earlier, interfaces could only contain abstract methods and constants. Java 8 added default methods (concrete implementations) and static methods — solving the API evolution problem. Java 9 added private methods for internal interface helper logic. Java 17 introduced sealed interfaces — restricting which classes can implement them. Modern Java interfaces are rich, powerful constructs.
Interface Declaration & Syntax — Anatomy of a Java Interface
Declaring a Java interface follows a specific structure. Understanding the syntax and implicit rules for each element prevents the most common interface-related compile errors.
[accessModifier] interface InterfaceName [extends Interface1, Interface2, ...] { // Constants (implicitly public static final) TYPE CONSTANT_NAME = value; // Abstract methods (implicitly public abstract) returnType methodName(params); // Default method (Java 8+) default returnType methodName(params) { body } // Static method (Java 8+) static returnType methodName(params) { body } // Private method (Java 9+) private returnType methodName(params) { body } }
• PascalCase — same as classes • Name as a capability/adjective: Runnable, Serializable, Closeable, Comparable, Iterable • Or as a noun representing a role: Repository, Service, Handler, Processor • Avoid 'IInterface' prefix (Hungarian notation) — not idiomatic Java • Good: Payable, Sortable, EventListener, NotificationSender • Avoid vague names: Manager, Helper, Util as interface names
Access: public (visible everywhere) or default/package-private (same package only). Top-level interfaces CANNOT be private or protected. Non-access: • abstract — implicit; every interface is abstract (no need to write) • sealed (Java 17+) — restricts permitted implementors • @FunctionalInterface — annotation validating exactly one abstract method Note: 'abstract interface' is redundant — omit 'abstract'; the compiler adds it.
// ── MINIMAL INTERFACE ─────────────────────────────────
public interface Greetable {
void greet(String name); // implicitly: public abstract void greet(String name)
}
// ── COMPLETE INTERFACE (Java 9+) ──────────────────────
public interface PaymentGateway {
// ── CONSTANTS (implicitly public static final) ────
int MAX_RETRY_ATTEMPTS = 3;
double PLATFORM_FEE_PERCENT = 1.5;
String DEFAULT_CURRENCY = "INR";
// ── ABSTRACT METHODS (implicitly public abstract) ─
PaymentResult processPayment(PaymentRequest request);
RefundResult processRefund(String transactionId, double amount);
boolean isAvailable();
// ── DEFAULT METHOD (Java 8+) ───────────────────────
// Concrete implementation — implementing classes inherit this
// and can override if needed
default PaymentResult processWithRetry(PaymentRequest request) {
for (int attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
logAttempt(attempt); // Calls private helper
PaymentResult result = processPayment(request);
if (result.isSuccess()) return result;
if (attempt < MAX_RETRY_ATTEMPTS) waitBeforeRetry(attempt);
}
return PaymentResult.failure("All " + MAX_RETRY_ATTEMPTS + " attempts failed");
}
default String formatAmount(double amount) {
return DEFAULT_CURRENCY + " " + String.format("%.2f", amount);
}
// ── STATIC METHOD (Java 8+) ────────────────────────
// Belongs to the interface itself — called as PaymentGateway.validate()
static boolean validateRequest(PaymentRequest request) {
return request != null
&& request.getAmount() > 0
&& request.getCurrency() != null
&& !request.getCurrency().isBlank();
}
// ── PRIVATE METHODS (Java 9+) ─────────────────────
// Internal helpers — NOT inherited by implementing classes
private void logAttempt(int attempt) {
System.out.printf("[PaymentGateway] Attempt %d of %d%n",
attempt, MAX_RETRY_ATTEMPTS);
}
private void waitBeforeRetry(int attempt) {
try {
Thread.sleep(500L * attempt); // Exponential backoff
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
private static String buildErrorMessage(int attempts) {
return "Payment failed after " + attempts + " attempts";
}
}Implementing an Interface — The implements Keyword
A class adopts an interface's contract using the implements keyword. Once a class declares it implements an interface, it must provide a concrete body for every abstract method in that interface — or declare itself abstract to defer the obligation to its subclasses. Failing to implement all abstract methods is a compile-time error.
public class ClassName extends ParentClass implements Interface1, Interface2, ... { // Must implement ALL abstract methods // from ALL implemented interfaces // @Override annotation strongly recommended } Note: 'extends' (if present) always comes BEFORE 'implements'.
1. MUST implement ALL abstract methods — or declare the class abstract. 2. Implemented methods MUST be public — interface methods are implicitly public; narrowing is a compile error. 3. @Override is recommended — catches method signature typos. 4. Can inherit default methods without overriding — but MUST override if two interfaces provide the same default method. 5. Can use super to call a specific interface's default: InterfaceName.super.method().
When a class implements an interface, 'instanceof' returns true for that interface type. A UPIGateway that implements PaymentGateway IS-A PaymentGateway. This enables polymorphism through interfaces — code written against the interface type works with ANY implementing class, decoupling callers from implementations.
// ── INTERFACE ─────────────────────────────────────────
public interface Drawable {
void draw();
void resize(double factor);
default String getDescription() {
return "A drawable shape";
}
}
public interface Colourable {
void setColour(String colour);
String getColour();
}
// ── CONCRETE CLASS implementing ONE interface ──────────
public class Circle implements Drawable {
private double radius;
private double x, y; // Centre coordinates
public Circle(double radius, double x, double y) {
this.radius = radius;
this.x = x;
this.y = y;
}
@Override
public void draw() {
System.out.printf("Drawing Circle at (%.1f, %.1f) radius=%.1f%n",
x, y, radius);
}
@Override
public void resize(double factor) {
if (factor <= 0) throw new IllegalArgumentException("Factor must be positive");
this.radius *= factor;
System.out.printf("Circle resized by %.1fx → radius=%.1f%n", factor, radius);
}
// Optional: override the default method
@Override
public String getDescription() {
return String.format("Circle at (%.1f,%.1f) with radius %.1f", x, y, radius);
}
}
// ── CONCRETE CLASS implementing TWO interfaces ─────────
public class Rectangle implements Drawable, Colourable {
private double width, height;
private String colour;
public Rectangle(double width, double height, String colour) {
this.width = width;
this.height = height;
this.colour = colour;
}
// Drawable contract
@Override
public void draw() {
System.out.printf("Drawing %s Rectangle [%.1f x %.1f]%n",
colour, width, height);
}
@Override
public void resize(double factor) {
width *= factor;
height *= factor;
}
// Colourable contract
@Override
public void setColour(String colour) { this.colour = colour; }
@Override
public String getColour() { return colour; }
}
// ── ABSTRACT CLASS — defers implementation ─────────────
public abstract class AbstractShape implements Drawable {
// Does NOT implement draw() or resize() — forces subclasses to
// Still gets the default getDescription() from Drawable
protected String shapeName;
protected AbstractShape(String name) { this.shapeName = name; }
}
// ── POLYMORPHISM via interface type ───────────────────
// List<Drawable> canvas = new ArrayList<>();
// canvas.add(new Circle(5, 0, 0));
// canvas.add(new Rectangle(4, 6, "Blue"));
// canvas.forEach(Drawable::draw); // Dynamic dispatch!Interface Members — Fields, Methods & Implicit Rules
Every member of a Java interface has implicit modifiers added by the compiler — regardless of what you write. Understanding these implicit rules prevents confusion about why certain code compiles and other code does not.
public interface CacheStore {
// ── CONSTANTS: implicitly public static final ──────
int DEFAULT_TTL_SECONDS = 3600; // = public static final int
int MAX_ENTRIES = 10_000; // = public static final int
String NULL_SENTINEL = "__NULL__";
// ── ABSTRACT METHODS: implicitly public abstract ───
void put(String key, Object value, int ttlSeconds);
Object get(String key);
void evict(String key);
void clear();
int size();
// ── DEFAULT METHODS (Java 8+): implicitly public ───
default void putWithDefaultTTL(String key, Object value) {
validateKey(key); // calls private helper
put(key, value, DEFAULT_TTL_SECONDS);
}
default boolean contains(String key) {
return get(key) != null;
}
default boolean isEmpty() {
return size() == 0;
}
// ── STATIC METHOD (Java 8+): belongs to interface ──
static CacheStore noOp() {
return new CacheStore() {
@Override public void put(String k, Object v, int t) {}
@Override public Object get(String k) { return null; }
@Override public void evict(String k) {}
@Override public void clear() {}
@Override public int size() { return 0; }
};
}
// ── PRIVATE METHOD (Java 9+): only usable inside interface
private void validateKey(String key) {
if (key == null || key.isBlank())
throw new IllegalArgumentException("Cache key cannot be blank");
if (key.length() > 250)
throw new IllegalArgumentException("Cache key too long");
}
// ── PRIVATE STATIC METHOD (Java 9+) ───────────────
private static String normaliseKey(String key) {
return key.trim().toLowerCase();
}
}
// Accessing the constant — three ways (all equivalent):
// CacheStore.DEFAULT_TTL_SECONDS
// new RedisCacheStore().DEFAULT_TTL_SECONDS (via instance — works but discouraged)
// Inside implementing class: DEFAULT_TTL_SECONDS (directly)Default Methods (Java 8+) — Evolving APIs Without Breaking Changes
Default methods are concrete method implementations inside an interface, declared with the default keyword. Introduced in Java 8, they solved a critical API design challenge: before Java 8, adding a new method to a published interface immediately broke every existing implementation. With default methods, a new method can carry a sensible default implementation — existing implementations continue working unchanged.
Before Java 8: adding forEach() to java.util.Collection would require updating every custom Collection implementation in the world. After Java 8: forEach() was added as a default method — existing implementations inherited a working forEach() using Iterator internally. No existing code broke. This is why the Java 8 Stream API integration was possible without breaking decades of existing Collection code.
When multiple sources provide a method with the same signature, Java resolves in this priority order: 1. Class or superclass method WINS over any interface default. 2. More specific interface wins over less specific (derived interface over base). 3. If two unrelated interfaces have the same default — the implementing class MUST explicitly override to resolve the conflict (compile error otherwise). 4. Call a specific interface's default: InterfaceName.super.methodName().
Default methods enable a form of 'mixin' — small, reusable behaviour that can be mixed into any class implementing the interface. Example: a 'Loggable' interface with a default log() method can be implemented by any class to gain logging capability. A 'Retryable' interface can provide a default executeWithRetry() used by any service. This is the foundation of modern Java's composable design.
// ── INTERFACE WITH DEFAULT METHODS ────────────────────
public interface Repository<T, ID> {
// Abstract — must be implemented
T findById(ID id);
java.util.List<T> findAll();
T save(T entity);
void deleteById(ID id);
long count();
// ── DEFAULT METHODS — shared convenience operations ──
default boolean existsById(ID id) {
return findById(id) != null;
}
default boolean isEmpty() {
return count() == 0;
}
default void saveAll(java.util.List<T> entities) {
if (entities == null) throw new IllegalArgumentException("List cannot be null");
entities.forEach(this::save); // Uses abstract save() via method ref
}
default java.util.Optional<T> findByIdOptional(ID id) {
return java.util.Optional.ofNullable(findById(id));
}
}
// ── CONCRETE IMPLEMENTATION — only 4 abstract methods ──
public class InMemoryUserRepository implements Repository<User, String> {
private final java.util.Map<String, User> store = new java.util.HashMap<>();
@Override
public User findById(String id) { return store.get(id); }
@Override
public java.util.List<User> findAll() {
return java.util.List.copyOf(store.values());
}
@Override
public User save(User user) {
store.put(user.getId(), user);
return user;
}
@Override
public void deleteById(String id) { store.remove(id); }
@Override
public long count() { return store.size(); }
// existsById(), isEmpty(), saveAll(), findByIdOptional()
// are all inherited from Repository — no code needed!
}
// ── DEFAULT METHOD CONFLICT RESOLUTION ────────────────
interface A {
default void greet() { System.out.println("Hello from A"); }
}
interface B {
default void greet() { System.out.println("Hello from B"); }
}
class C implements A, B {
@Override
public void greet() {
A.super.greet(); // ✅ Explicitly choose A's version
// OR B.super.greet(); for B's version
// OR write completely new: System.out.println("Hello from C");
}
}Static Methods in Interfaces (Java 8+)
Static methods in interfaces (Java 8+) belong to the interface itself — not to implementing classes or objects. They are called directly on the interface: InterfaceName.methodName(). They are NOT inherited by implementing classes and cannot be overridden. They serve as namespace-organised utility methods tightly associated with the interface's purpose.
Factory methods: 'Comparator.comparing(keyExtractor)' — creates a Comparator without needing a separate utility class. Validation utilities: 'PaymentGateway.validateRequest(req)'. Default instance creation: 'Executor.newVirtualThreadPerTaskExecutor()'. Before Java 8, these would live in separate utility classes (Collections, Arrays). Static interface methods place utilities where they logically belong — on the interface itself.
Unlike default methods, static interface methods are NOT inherited by implementing classes. If UPIGateway implements PaymentGateway, calling 'UPIGateway.validateRequest(req)' is a compile error — it must be 'PaymentGateway.validateRequest(req)'. This is by design — static methods are tied to the interface namespace, not to instances. This avoids confusion with method hiding.
Comparator.comparing(User::getName) — factory for key-based comparator Comparator.naturalOrder() / reverseOrder() Predicate.not(Predicate) — negates a predicate Function.identity() — returns its argument List.of(elements), Set.of(elements), Map.of(k,v) — immutable collection factories Stream.of(elements) — stream factory All of these are static methods on interfaces, called via the interface name.
import java.util.*;
import java.util.function.*;
public interface Validator<T> {
// Abstract — must be implemented
ValidationResult validate(T value);
// Default — composable validators
default Validator<T> and(Validator<T> other) {
return value -> {
ValidationResult first = this.validate(value);
if (!first.isValid()) return first;
return other.validate(value);
};
}
default Validator<T> or(Validator<T> other) {
return value -> {
ValidationResult first = this.validate(value);
if (first.isValid()) return first;
return other.validate(value);
};
}
// ── STATIC FACTORY METHODS ────────────────────────
// Called as: Validator.notNull(), Validator.minLength(5)
static <T> Validator<T> notNull() {
return value -> value == null
? ValidationResult.invalid("Value cannot be null")
: ValidationResult.valid();
}
static Validator<String> notBlank() {
return value -> (value == null || value.isBlank())
? ValidationResult.invalid("Value cannot be blank")
: ValidationResult.valid();
}
static Validator<String> minLength(int min) {
return value -> (value != null && value.length() >= min)
? ValidationResult.valid()
: ValidationResult.invalid("Must be at least " + min + " characters");
}
static Validator<String> maxLength(int max) {
return value -> (value != null && value.length() <= max)
? ValidationResult.valid()
: ValidationResult.invalid("Must not exceed " + max + " characters");
}
static Validator<String> matchesPattern(String regex) {
return value -> (value != null && value.matches(regex))
? ValidationResult.valid()
: ValidationResult.invalid("Does not match required pattern");
}
static Validator<Integer> inRange(int min, int max) {
return value -> (value != null && value >= min && value <= max)
? ValidationResult.valid()
: ValidationResult.invalid("Must be between " + min + " and " + max);
}
}
// ── USAGE — composing validators ──────────────────────
// Validator<String> passwordValidator =
// Validator.notBlank()
// .and(Validator.minLength(8))
// .and(Validator.maxLength(50))
// .and(Validator.matchesPattern(".*[A-Z].*"))
// .and(Validator.matchesPattern(".*[0-9].*"));
//
// ValidationResult r = passwordValidator.validate("MyPass123");
// System.out.println(r.isValid()); // truePrivate Methods in Interfaces (Java 9+)
Private methods in interfaces (Java 9+) are concrete methods inside an interface that are only accessible within the interface itself. They are NOT inherited by implementing classes and NOT accessible from outside the interface. Their sole purpose is to eliminate code duplication among default and static methods within the same interface.
private instance methods: can be called by default methods in the same interface. They have access to 'this' (the implementing object) via the default method context. private static methods: can be called by static methods AND default methods in the same interface. They cannot access 'this'. Use private static when the helper doesn't need the implementing object's state.
Before Java 9: if two default methods shared common logic, you had to either duplicate the code or expose a helper as another default method (polluting the interface's public API with implementation details). Java 9 private methods solve this cleanly — the shared logic is extracted to a private helper that is invisible to implementing classes and external callers.
1. Must have a body — cannot be abstract. 2. Cannot be default (the keywords cannot be combined). 3. private instance methods: callable by default methods. 4. private static methods: callable by both default and static methods. 5. NOT inherited — not visible outside the interface. 6. Cannot be accessed via InterfaceName.super — they are implementation details, not contract.
public interface AuditableService {
// Abstract — implementing class provides these
String getServiceName();
Object executeOperation(String operationName, Object payload);
// ── DEFAULT METHODS — use private helpers ─────────
default Object executeWithAudit(String operationName, Object payload) {
logStart(operationName); // Private instance
long startTime = System.currentTimeMillis();
try {
Object result = executeOperation(operationName, payload);
long elapsed = System.currentTimeMillis() - startTime;
logSuccess(operationName, elapsed); // Private instance
return result;
} catch (Exception e) {
logFailure(operationName, e); // Private instance
throw e;
}
}
default Object executeWithAuditAndRetry(String op, Object payload, int maxRetries) {
logStart(op); // Reusing private helper
for (int i = 1; i <= maxRetries; i++) {
try {
Object result = executeOperation(op, payload);
logSuccess(op, 0);
return result;
} catch (Exception e) {
if (i == maxRetries) {
logFailure(op, e);
throw e;
}
logRetry(op, i, maxRetries); // Private instance
}
}
throw new IllegalStateException("Should not reach here");
}
// ── STATIC DEFAULT — uses private static helper ───
static String buildCorrelationId() {
return generateId(); // Private static
}
// ── PRIVATE INSTANCE HELPERS ──────────────────────
// NOT inherited — NOT visible outside interface
private void logStart(String operation) {
System.out.printf("[%s] START: %s%n", getServiceName(), operation);
}
private void logSuccess(String operation, long elapsedMs) {
System.out.printf("[%s] SUCCESS: %s (%dms)%n",
getServiceName(), operation, elapsedMs);
}
private void logFailure(String operation, Exception e) {
System.out.printf("[%s] FAILURE: %s — %s%n",
getServiceName(), operation, e.getMessage());
}
private void logRetry(String op, int attempt, int max) {
System.out.printf("[%s] RETRY %d/%d: %s%n",
getServiceName(), attempt, max, op);
}
// ── PRIVATE STATIC HELPER ─────────────────────────
private static String generateId() {
return "CID-" + java.util.UUID.randomUUID().toString().substring(0, 8);
}
}
// Implementing class — none of the private methods are visible here
public class OrderService implements AuditableService {
@Override
public String getServiceName() { return "OrderService"; }
@Override
public Object executeOperation(String op, Object payload) {
System.out.println("Executing " + op + " with " + payload);
return "Result of " + op;
}
// Uses inherited executeWithAudit() and executeWithAuditAndRetry()
// private helpers (logStart, logSuccess etc.) are completely hidden
}Implementing Multiple Interfaces — Java's Answer to Multiple Inheritance
A Java class can implement multiple interfaces simultaneously — this is how Java achieves the benefits of multiple inheritance without the Diamond Problem. Each interface the class implements adds a new type to the class, enabling extremely flexible polymorphic code. A class can declare its capabilities through multiple interface implementations, and callers can use whichever type fits their need.
When a class implements multiple interfaces, it satisfies multiple IS-A relationships simultaneously. A Duck class that implements Flyable, Swimmable, and Quackable IS-A Flyable, IS-A Swimmable, and IS-A Quackable. Each interface type can be used as the reference type for a Duck variable. This lets different parts of the codebase interact with a Duck only through the capability they care about.
When two interfaces provide the same default method and a class implements both, Java forces the implementor to resolve the conflict explicitly by overriding the method. Inside the override, the class can call a specific interface's default using 'InterfaceName.super.methodName()'. This explicit resolution makes the intent clear and avoids hidden ambiguity — unlike C++ multiple inheritance where the conflict resolution can be subtle.
Don't force clients to depend on methods they don't use. Instead of one fat interface, create multiple focused ones. A Printer that prints documents should implement Printable. A Scanner that scans should implement Scannable. An all-in-one device implements both. Clients that only print use Printable — they're unaffected if Scannable changes. This is the 'I' in SOLID.
// ── SEGREGATED INTERFACES ─────────────────────────────
public interface Readable {
String read(String source);
boolean canRead(String source);
}
public interface Writable {
void write(String destination, String content);
boolean canWrite(String destination);
}
public interface Seekable {
void seek(long position);
long currentPosition();
}
public interface Closeable {
void close();
boolean isClosed();
default void closeQuietly() {
try { if (!isClosed()) close(); }
catch (Exception ignored) {}
}
}
// ── CLASS IMPLEMENTING MULTIPLE INTERFACES ─────────────
public class FileStream implements Readable, Writable, Seekable, Closeable {
private final String filePath;
private long position;
private boolean closed;
public FileStream(String filePath) {
this.filePath = filePath;
this.position = 0;
this.closed = false;
}
// Readable contract
@Override public boolean canRead(String src) { return !closed; }
@Override public String read(String src) {
if (closed) throw new IllegalStateException("Stream is closed");
System.out.println("Reading from " + filePath + " at pos " + position);
return "content";
}
// Writable contract
@Override public boolean canWrite(String dest) { return !closed; }
@Override public void write(String dest, String content) {
if (closed) throw new IllegalStateException("Stream is closed");
System.out.println("Writing to " + filePath + ": " + content);
}
// Seekable contract
@Override public void seek(long pos) { this.position = pos; }
@Override public long currentPosition() { return position; }
// Closeable contract
@Override public void close() { this.closed = true; }
@Override public boolean isClosed() { return closed; }
}
// ── POLYMORPHIC USAGE — each caller uses only what it needs ─
static void copyContent(Readable src, Writable dest) {
// This method doesn't know FileStream exists
// It only cares about Readable and Writable
if (src.canRead("src") && dest.canWrite("dest")) {
String content = src.read("src");
dest.write("dest", content);
}
}
static void resetStream(Seekable seekable) {
seekable.seek(0);
System.out.println("Stream reset to position 0");
}
// FileStream satisfies ALL four types:
// Readable r = new FileStream("file.txt"); ✅
// Writable w = new FileStream("file.txt"); ✅
// Seekable s = new FileStream("file.txt"); ✅
// Closeable c = new FileStream("file.txt"); ✅Interface Extending Interface — Building Rich Type Hierarchies
An interface can extend one or more other interfaces using the extends keyword (NOT implements). This creates an interface hierarchy where the derived interface inherits all abstract and default methods from its parent interfaces and can add new methods. A class implementing the derived interface must satisfy the contracts of the entire hierarchy.
// ── BASE INTERFACES ───────────────────────────────────
public interface ReadRepository<T, ID> {
T findById(ID id);
java.util.List<T> findAll();
long count();
boolean existsById(ID id);
}
public interface WriteRepository<T, ID> {
T save(T entity);
void deleteById(ID id);
void deleteAll();
void saveAll(java.util.List<T> entities);
}
// ── DERIVED INTERFACE — extends two base interfaces ────
// A class implementing this MUST satisfy BOTH contracts
public interface CrudRepository<T, ID>
extends ReadRepository<T, ID>, WriteRepository<T, ID> {
// Additional methods beyond read + write
T update(ID id, T updatedEntity);
// Default — uses inherited abstract methods
default boolean existsAndDelete(ID id) {
if (!existsById(id)) return false; // from ReadRepository
deleteById(id); // from WriteRepository
return true;
}
default T saveIfNotExists(ID id, T entity) {
if (existsById(id)) return findById(id); // from ReadRepository
return save(entity); // from WriteRepository
}
}
// ── FURTHER DERIVED — adds paging and search ──────────
public interface PagedRepository<T, ID> extends CrudRepository<T, ID> {
java.util.List<T> findPage(int pageNumber, int pageSize);
java.util.List<T> search(String query);
long countMatching(String query);
default int totalPages(int pageSize) {
long total = count(); // Inherited from ReadRepository via CrudRepository
return (int) Math.ceil((double) total / pageSize);
}
}
// ── IMPLEMENTATION — must fulfil ENTIRE hierarchy ──────
public class UserRepository implements PagedRepository<User, String> {
private final java.util.Map<String, User> store = new java.util.LinkedHashMap<>();
// ReadRepository methods
@Override public User findById(String id) { return store.get(id); }
@Override public java.util.List<User> findAll() { return java.util.List.copyOf(store.values()); }
@Override public long count() { return store.size(); }
@Override public boolean existsById(String id) { return store.containsKey(id); }
// WriteRepository methods
@Override public User save(User u) { store.put(u.getId(), u); return u; }
@Override public void deleteById(String id) { store.remove(id); }
@Override public void deleteAll() { store.clear(); }
@Override public void saveAll(java.util.List<User> users) { users.forEach(this::save); }
// CrudRepository method
@Override public User update(String id, User updated) {
if (!store.containsKey(id)) throw new java.util.NoSuchElementException();
store.put(id, updated);
return updated;
}
// PagedRepository methods
@Override public java.util.List<User> findPage(int page, int size) {
return store.values().stream()
.skip((long) page * size).limit(size).toList();
}
@Override public java.util.List<User> search(String q) {
return store.values().stream()
.filter(u -> u.getName().toLowerCase().contains(q.toLowerCase()))
.toList();
}
@Override public long countMatching(String q) { return search(q).size(); }
// existsAndDelete(), saveIfNotExists(), totalPages() all inherited as defaults!
}Functional Interfaces & Lambdas — The Heart of Modern Java
A functional interface is an interface with exactly one abstract method (SAM — Single Abstract Method). It may have any number of default, static, or private methods. The @FunctionalInterface annotation signals intent and enforces the single-abstract-method constraint at compile time. Functional interfaces are the target types for lambda expressions and method references — Java's most significant feature addition since generics.
Java 8 ships with 43 functional interfaces in java.util.function. The 4 core categories: • Predicate<T>: T → boolean — test(T t) • Function<T,R>: T → R — apply(T t) • Consumer<T>: T → void — accept(T t) • Supplier<T>: () → T — get() Specialised variants: BiFunction<T,U,R>, UnaryOperator<T>, BinaryOperator<T>, IntPredicate, LongFunction, etc.
A lambda is a concise, inline implementation of a functional interface. Syntax: '(params) -> body'. If the body is a single expression, no return or braces needed. Examples: Runnable r = () -> System.out.println("Hi"); Predicate<String> isLong = s -> s.length() > 10; Function<String,Integer> strLen = String::length; (method ref) Comparator<User> byAge = (a, b) -> Integer.compare(a.getAge(), b.getAge());
Built-in functional interfaces provide composition methods: Predicate: and(), or(), negate() Function: andThen(), compose() Comparator: thenComparing(), reversed() Example: Predicate<String> notNull = s -> s != null; Predicate<String> notBlank = s -> !s.isBlank(); Predicate<String> valid = notNull.and(notBlank); // valid.test("hello") → true
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
// ── CUSTOM FUNCTIONAL INTERFACE ───────────────────────
@FunctionalInterface
public interface OrderProcessor {
ProcessingResult process(Order order);
// Default and static — do NOT count as abstract
default OrderProcessor andThen(OrderProcessor next) {
return order -> {
ProcessingResult r = this.process(order);
return r.isSuccess() ? next.process(order) : r;
};
}
static OrderProcessor noOp() {
return order -> ProcessingResult.success();
}
}
// ── USING LAMBDAS WITH BUILT-IN FUNCTIONAL INTERFACES ─
public class FunctionalDemo {
public static void main(String[] args) {
List<String> names = List.of("Ravi", "Priya", "Arjun", "Meena", "Dev");
// Predicate<T>: T → boolean
Predicate<String> longName = name -> name.length() > 4;
Predicate<String> startsWithP = name -> name.startsWith("P");
// Function<T,R>: T → R
Function<String, String> toUpper = String::toUpperCase;
Function<String, Integer> length = String::length;
// Consumer<T>: T → void
Consumer<String> printer = System.out::println;
Consumer<String> withTag = name -> System.out.println("[USER] " + name);
// Supplier<T>: () → T
Supplier<List<String>> listFactory = ArrayList::new;
// Comparator
Comparator<String> byLength = Comparator.comparingInt(String::length)
.thenComparing(Comparator.naturalOrder());
// ── STREAM PIPELINE using all of the above ────
List<String> result = names.stream()
.filter(longName.or(startsWithP)) // Predicate composition
.map(toUpper) // Function
.sorted(byLength) // Comparator
.collect(Collectors.toList());
result.forEach(printer); // Consumer
// Output: PRIYA, MEENA, ARJUN
// ── CUSTOM FUNCTIONAL INTERFACE with lambda ───
OrderProcessor validate = order ->
order.isValid() ? ProcessingResult.success()
: ProcessingResult.failure("Invalid order");
OrderProcessor charge = order ->
order.hasPayment() ? ProcessingResult.success()
: ProcessingResult.failure("No payment");
OrderProcessor pipeline = validate.andThen(charge); // Composing!
// ── BiFunction — two input params ──────────────
BiFunction<String, Integer, String> repeat =
(str, times) -> str.repeat(times);
System.out.println(repeat.apply("Java", 3)); // JavaJavaJava
// ── UnaryOperator — same input and output type ─
UnaryOperator<String> trim = String::trim;
UnaryOperator<String> lower = String::toLowerCase;
UnaryOperator<String> normalise = trim.andThen(lower);
System.out.println(normalise.apply(" HELLO ")); // hello
}
}Marker Interfaces — Tagging Without Methods
A marker interface (also called a tag interface) is an interface with no methods and no fields. Its only purpose is to mark or tag a class as having a certain property — to communicate metadata about the class to the JVM, frameworks, or other code. The tag is detectable via instanceof or reflection.
java.io.Serializable: marks a class whose objects can be converted to a byte stream. JVM's ObjectOutputStream checks instanceof Serializable before serialising. java.lang.Cloneable: marks a class whose objects can be cloned via Object.clone(). Without this, clone() throws CloneNotSupportedException. java.util.RandomAccess: marks List implementations supporting constant-time positional access — Collections.binarySearch() uses instanceof RandomAccess to choose the optimal algorithm.
Since Java 5, annotations are the preferred way to tag classes with metadata. '@Override', '@Deprecated', '@Entity', '@Service' all serve as modern 'markers'. Annotations are more powerful: they can carry data, be targeted at specific element types, and be processed at compile time, runtime, or both. Marker interfaces are still used in legacy code and for IS-A checks via instanceof.
In domain-driven design: 'interface DomainEvent {}' — marks all events. Frameworks check 'if (obj instanceof DomainEvent)' to route appropriately. Security: 'interface Sensitive {}' — marks DTOs containing sensitive data; a serialisation filter checks for this marker. Audit: 'interface Auditable {}' — an AOP aspect intercepts calls on Auditable classes. Each is simple and effective for type-based dispatch.
// ── BUILT-IN: Serializable marker ─────────────────────
import java.io.Serializable;
public class UserProfile implements Serializable {
// No additional methods from Serializable — it's a marker!
private static final long serialVersionUID = 1L;
private String userId;
private String displayName;
// JVM allows ObjectOutputStream to serialise this class
}
// ── CUSTOM MARKER INTERFACE ───────────────────────────
// Marker 1: Signals that a class's toString() output is safe to log
public interface SafeToLog {
// No methods — just a tag
}
// Marker 2: Signals that a DTO may contain sensitive PII data
public interface ContainsPII {
// No methods — just a tag
}
// Marker 3: Signals that a domain event is important for audit
public interface AuditableEvent {
// No methods — just a tag
}
// ── CLASSES USING MARKERS ─────────────────────────────
public class OrderCreatedEvent implements AuditableEvent, SafeToLog {
private final String orderId;
private final double amount;
private final String customerId;
public OrderCreatedEvent(String orderId, double amount, String customerId) {
this.orderId = orderId;
this.amount = amount;
this.customerId = customerId;
}
@Override
public String toString() {
return "OrderCreatedEvent{orderId='" + orderId + "', amount=" + amount + "}";
}
}
public class PaymentDetailsDTO implements ContainsPII {
private String cardNumber; // PII — must be masked in logs
private String cvv;
private String cardHolder;
}
// ── MARKER CHECKED AT RUNTIME ─────────────────────────
public class EventPublisher {
public void publish(Object event) {
// Check marker — only log events that declare they are safe
if (event instanceof SafeToLog) {
System.out.println("[EVENT LOG] " + event);
} else {
System.out.println("[EVENT LOG] Event published (details hidden)");
}
// Check audit marker
if (event instanceof AuditableEvent) {
auditTrail.record(event);
}
}
}
public class DataLogger {
public void log(Object data) {
if (data instanceof ContainsPII) {
// Mask or skip PII data
System.out.println("[LOG] <PII data masked>");
} else {
System.out.println("[LOG] " + data);
}
}
}Interface vs Abstract Class — When to Use Which
Choosing between an interface and an abstract class is one of the most common design decisions in Java OOP. Both provide abstraction, but they serve fundamentally different purposes. The distinction has become more nuanced since Java 8 added default methods to interfaces, but the core guidance remains clear.
// ── USE INTERFACE: defining a capability ──────────────
// Any class — related or not — can be Exportable
public interface Exportable {
byte[] exportToBytes();
String exportToJson();
default void exportToFile(String path) {
// Default: write bytes to file
try (var out = new java.io.FileOutputStream(path)) {
out.write(exportToBytes());
} catch (java.io.IOException e) {
throw new RuntimeException("Export failed", e);
}
}
}
// Unrelated classes can both be Exportable
class Invoice implements Exportable { /* ... */ }
class UserReport implements Exportable { /* ... */ }
class ConfigSnapshot implements Exportable { /* ... */ }
// ── USE ABSTRACT CLASS: shared state + template ───────
// All reports SHARE common fields and the generate() skeleton
public abstract class BaseReport {
// Shared state — only possible in abstract class
protected final String reportId;
protected final String generatedBy;
protected final java.time.LocalDateTime generatedAt;
protected BaseReport(String generatedBy) {
this.reportId = java.util.UUID.randomUUID().toString();
this.generatedBy = generatedBy;
this.generatedAt = java.time.LocalDateTime.now();
}
// Template method — fixed algorithm with overridable steps
public final String generate() {
String header = buildHeader();
String body = buildBody(); // Abstract — must override
String footer = buildFooter();
return header + "\n" + body + "\n" + footer;
}
protected abstract String buildBody(); // Must override
protected String buildHeader() {
return "=== Report: " + reportId + " | By: " + generatedBy + " ===";
}
protected String buildFooter() {
return "Generated at: " + generatedAt;
}
}
// Subclasses only implement what differs
class SalesReport extends BaseReport {
SalesReport(String by) { super(by); }
@Override
protected String buildBody() { return "Sales data here..."; }
}
// ── BEST OF BOTH: interface + abstract class ──────────
// Pattern used in java.util (AbstractList implements List)
public interface ReportGenerator {
Report generate(ReportRequest request);
String getSupportedFormat();
}
// Abstract class provides partial implementation
public abstract class AbstractReportGenerator implements ReportGenerator {
protected final ReportRepository repository;
protected AbstractReportGenerator(ReportRepository repo) {
this.repository = repo;
}
// Concrete — shared logic for all generators
protected void validateRequest(ReportRequest request) {
if (request == null) throw new IllegalArgumentException();
}
// Abstract — each format implements differently
protected abstract ReportBody formatBody(java.util.List<?> data);
}
// PdfReportGenerator, ExcelReportGenerator, CsvReportGenerator all extend thisSealed Interfaces (Java 17+) — Controlled Extensibility
Sealed interfaces (Java 17, JEP 409) restrict which classes or interfaces can implement them. Declared with the sealed keyword and a permits clause, they give API designers controlled extensibility — the interface is open for use but closed for implementation to an explicit, known set of types. This enables exhaustive pattern matching in switch expressions.
1. Declared with 'sealed' + 'permits ClassName, ...' listing every permitted implementor. 2. Permitted classes MUST directly implement or extend the sealed interface. 3. Permitted classes MUST be in the same package (or module) as the sealed interface. 4. Each permitted class must be one of: 'final' (no further subclassing), 'sealed' (further restricts), or 'non-sealed' (opens back up for extension).
Enables exhaustive switch pattern matching — if all permitted types are known, the compiler can verify that a switch covers all cases without a default. This is how Java models algebraic data types (sum types). Example: a Shape sealed interface with Circle, Rectangle, Triangle as permitted types — a switch on Shape must handle all three, and the compiler enforces this. This is safer than open hierarchies where new subclasses can appear unexpectedly.
Java records (Java 16+) pair beautifully with sealed interfaces. Records are implicitly final, making them perfect permitted types — they carry data without mutable state. Pattern: 'sealed interface Shape permits Circle, Rectangle, Triangle' where each is a record: 'record Circle(double radius) implements Shape'. This is modern Java's concise, type-safe algebraic data type pattern used in compilers, parsers, and domain event hierarchies.
// ── SEALED INTERFACE (Java 17+) ───────────────────────
public sealed interface Shape
permits Circle, Rectangle, Triangle, RegularPolygon {
double getArea();
double getPerimeter();
default String describe() {
return String.format("%s | Area: %.2f | Perimeter: %.2f",
getClass().getSimpleName(), getArea(), getPerimeter());
}
}
// ── PERMITTED IMPLEMENTORS ────────────────────────────
// 'final' — cannot be further subclassed
public final class Circle implements Shape {
private final double radius;
public Circle(double radius) {
if (radius <= 0) throw new IllegalArgumentException();
this.radius = radius;
}
@Override public double getArea() { return Math.PI * radius * radius; }
@Override public double getPerimeter() { return 2 * Math.PI * radius; }
public double getRadius() { return radius; }
}
// Using a record — concise and implicitly final
public record Rectangle(double width, double height) implements Shape {
public Rectangle { // Compact constructor — validation
if (width <= 0 || height <= 0)
throw new IllegalArgumentException("Dimensions must be positive");
}
@Override public double getArea() { return width * height; }
@Override public double getPerimeter() { return 2 * (width + height); }
}
public record Triangle(double a, double b, double c) implements Shape {
public Triangle {
if (a + b <= c || b + c <= a || a + c <= b)
throw new IllegalArgumentException("Invalid triangle sides");
}
@Override public double getArea() {
double s = (a + b + c) / 2;
return Math.sqrt(s * (s-a) * (s-b) * (s-c));
}
@Override public double getPerimeter() { return a + b + c; }
}
// 'non-sealed' — reopens the hierarchy for further extension
public non-sealed class RegularPolygon implements Shape {
protected final int sides;
protected final double sideLength;
public RegularPolygon(int sides, double sideLength) {
this.sides = sides; this.sideLength = sideLength;
}
@Override public double getArea() {
return (sides * sideLength * sideLength)
/ (4 * Math.tan(Math.PI / sides));
}
@Override public double getPerimeter() { return sides * sideLength; }
}
// ── EXHAUSTIVE SWITCH PATTERN MATCHING (Java 21) ──────
public class ShapeCalculator {
// Compiler KNOWS all permitted types — exhaustive switch, NO default needed
public static String describeShape(Shape shape) {
return switch (shape) {
case Circle c -> "Circle with radius " + c.getRadius();
case Rectangle r -> "Rectangle " + r.width() + " × " + r.height();
case Triangle t -> "Triangle with sides " + t.a() + ", " + t.b() + ", " + t.c();
case RegularPolygon p -> "Regular " + p.sides + "-gon";
// No default needed — compiler verifies exhaustiveness!
};
}
public static double totalArea(java.util.List<Shape> shapes) {
return shapes.stream()
.mapToDouble(Shape::getArea)
.sum();
}
}Common Mistakes & Pitfalls — Bugs That Trip Everyone Up
These interface-related mistakes appear consistently in Java beginner and intermediate code. Each one either causes a compile-time error or a subtle design problem that surfaces later during maintenance.
// ❌ MISTAKE 1: Making interface method non-public in implementing class
interface Printable { void print(); } // implicitly public
class Document implements Printable {
// void print() { } // ❌ Compile error — reduces public to default
public void print() { System.out.println("Printing"); } // ✅ Must be public
}
// ❌ MISTAKE 2: Treating interface constants as instance variables
interface Config {
int MAX_RETRY = 3; // implicitly public static final
}
class MyService implements Config {
public void serve() {
// int MAX_RETRY = 5; // ❌ Cannot reassign — it's final
// Worse: accessing it via 'this.MAX_RETRY' is misleading
System.out.println(MAX_RETRY); // ✅ Direct access — but use Config.MAX_RETRY
}
}
// ❌ MISTAKE 3: Writing 'abstract' explicitly on interface methods
interface Vehicle {
public abstract void start(); // 'public abstract' is redundant — already implicit
void stop(); // ✅ Cleaner — same result
}
// ❌ MISTAKE 4: Using 'implements' between interfaces
// interface B implements A { } // ❌ Compile error — interfaces use 'extends'
interface A { void methodA(); }
interface B extends A { void methodB(); } // ✅ Correct
// ❌ MISTAKE 5: Forgetting to implement all abstract methods
interface Flyable { void fly(); void land(); }
// class Eagle implements Flyable {
// public void fly() { System.out.println("Flying"); }
// // ❌ Compile error: Eagle is not abstract and does not override land()
// }
// ✅ Fix: implement both, or declare class abstract
class Eagle implements Flyable {
@Override public void fly() { System.out.println("Flying high!"); }
@Override public void land() { System.out.println("Landing safely."); }
}
// ❌ MISTAKE 6: Two interfaces with conflicting defaults — not resolving
interface Logger { default void log() { System.out.println("Logger"); } }
interface Auditor { default void log() { System.out.println("Auditor"); } }
// class Service implements Logger, Auditor { } // ❌ Compile error — ambiguous default
// ✅ Fix: explicitly resolve the conflict
class Service implements Logger, Auditor {
@Override
public void log() {
Logger.super.log(); // Pick one, or write your own
Auditor.super.log();
}
}
// ❌ MISTAKE 7: Calling interface static method via implementing class
interface MathOps { static int square(int n) { return n * n; } }
class Calculator implements MathOps { }
// Calculator.square(5); // ❌ Compile error — static interface methods not inherited
// ✅ Fix:
MathOps.square(5); // ✅ Called on the interface itselfBad Practices & Anti-Patterns — What Senior Developers Reject
These interface anti-patterns are consistently rejected in professional code reviews. Each violates design principles and makes codebases harder to maintain, test, and evolve.
Using an interface purely to hold constants that classes implement to 'inherit' them. Example: 'interface Constants { int MAX=100; String BASE_URL="..."; }'. Implementing classes inherit these constants but now have 'Constants' as a public IS-A type — a meaningless API commitment. Classes should not implement interfaces just for constant access. Fix: use a final utility class with private constructor: 'public final class AppConstants { private AppConstants(){} public static final int MAX = 100; }'
An interface with 20+ methods that no single class realistically needs all of. Implementing classes must provide empty/stub implementations for irrelevant methods. Any change to the interface forces updates across all implementors. Fix: apply Interface Segregation Principle — split into focused, cohesive interfaces. A UserService doesn't need to implement UserRepository, UserNotificationService, and UserAuditService all in one contract.
Adding substantial business logic as default methods, effectively turning the interface into a partial abstract class. Interfaces should define contracts and optionally provide thin convenience defaults. When a default method is long, complex, or depends on many other methods — it signals the logic belongs in an abstract class or a shared utility. The interface is becoming a tangled mix of contract and implementation.
Defining an interface intended as a lambda target without @FunctionalInterface. Without the annotation, accidentally adding a second abstract method is a compile-but-silently-breaks situation — all lambdas targeting that interface now fail. @FunctionalInterface is a defensive annotation: if someone adds a second abstract method, it immediately fails to compile. Always annotate intentional functional interfaces.
Some developers create an interface for every class 'just in case'. 'UserService' interface with 'UserServiceImpl' as the only implementation forever. This adds a layer of abstraction with no value — every change requires updating both the interface and the class. Create interfaces when: multiple implementations exist or are expected, you want to decouple callers from implementations, or you're designing a library API. Don't create 1:1 interface-class pairs reflexively.
Adding framework-specific or technology-specific methods to a domain interface. Example: 'interface UserRepository { ... ; EntityManager getEntityManager(); }'. Now every caller of UserRepository is coupled to JPA/Hibernate. The interface should model the domain contract only. Technology details belong in the implementing class. Keep interfaces pure — they represent what the caller needs, not what the implementation uses.
Real-World Production Code Examples — Interfaces in Context
The following examples demonstrate carefully designed interfaces from real enterprise Java applications — showing how interface hierarchies, default methods, functional interfaces, and sealed interfaces combine in production-grade code.
package com.techsustainify.notification;
import java.util.concurrent.CompletableFuture;
/**
* Contract for notification delivery channels.
* Implementations: EmailChannel, SmsChannel, PushChannel, WhatsAppChannel.
* Uses default methods for retry logic and async delivery.
*/
public interface NotificationChannel {
// ── CONSTANTS ─────────────────────────────────────
int DEFAULT_MAX_RETRIES = 3;
long DEFAULT_RETRY_DELAY_MS = 1000L;
int MAX_MESSAGE_LENGTH = 1600;
// ── ABSTRACT CONTRACT ─────────────────────────────
String getChannelName();
boolean isAvailable();
DeliveryResult deliver(NotificationMessage message);
boolean supportsRichContent();
// ── DEFAULT METHODS ───────────────────────────────
/** Deliver with exponential backoff retry */
default DeliveryResult deliverWithRetry(NotificationMessage message) {
return deliverWithRetry(message, DEFAULT_MAX_RETRIES);
}
default DeliveryResult deliverWithRetry(NotificationMessage msg, int maxRetries) {
validateMessage(msg); // private helper
for (int attempt = 1; attempt <= maxRetries; attempt++) {
if (!isAvailable()) {
return DeliveryResult.failure(getChannelName() + " unavailable");
}
DeliveryResult result = deliver(msg);
if (result.isSuccess()) {
logDelivery(msg, attempt); // private helper
return result;
}
if (attempt < maxRetries) {
sleepWithBackoff(attempt); // private static helper
}
}
return DeliveryResult.failure("Delivery failed after " + maxRetries + " attempts");
}
/** Non-blocking async delivery */
default CompletableFuture<DeliveryResult> deliverAsync(NotificationMessage msg) {
return CompletableFuture.supplyAsync(() -> deliverWithRetry(msg));
}
/** Check if this channel can handle the given message type */
default boolean canHandle(NotificationMessage message) {
if (message == null) return false;
if (!supportsRichContent() && message.isRichContent()) return false;
return message.getBody().length() <= MAX_MESSAGE_LENGTH;
}
// ── STATIC FACTORY ────────────────────────────────
static NotificationChannel noOp() {
return new NotificationChannel() {
@Override public String getChannelName() { return "NoOp"; }
@Override public boolean isAvailable() { return true; }
@Override public DeliveryResult deliver(NotificationMessage m)
{ return DeliveryResult.success("NoOp"); }
@Override public boolean supportsRichContent() { return false; }
};
}
// ── PRIVATE HELPERS ───────────────────────────────
private void validateMessage(NotificationMessage message) {
if (message == null)
throw new IllegalArgumentException("Message cannot be null");
if (message.getRecipientId() == null || message.getRecipientId().isBlank())
throw new IllegalArgumentException("Recipient ID required");
if (message.getBody() == null || message.getBody().isBlank())
throw new IllegalArgumentException("Message body required");
}
private void logDelivery(NotificationMessage msg, int attempts) {
System.out.printf("[%s] Delivered to %s in %d attempt(s)%n",
getChannelName(), msg.getRecipientId(), attempts);
}
private static void sleepWithBackoff(int attempt) {
try {
Thread.sleep(DEFAULT_RETRY_DELAY_MS * attempt);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
// ── CONCRETE IMPLEMENTATION ───────────────────────────
public class EmailChannel implements NotificationChannel {
private final EmailClient client;
private final String fromAddress;
private boolean circuitOpen;
public EmailChannel(EmailClient client, String fromAddress) {
this.client = client;
this.fromAddress = fromAddress;
this.circuitOpen = false;
}
@Override public String getChannelName() { return "EMAIL"; }
@Override public boolean supportsRichContent() { return true; }
@Override public boolean isAvailable() { return !circuitOpen && client.isConnected(); }
@Override
public DeliveryResult deliver(NotificationMessage message) {
try {
client.send(
message.getRecipientEmail(),
fromAddress,
message.getSubject(),
message.getBody(),
message.isRichContent()
);
return DeliveryResult.success("Email sent");
} catch (EmailException e) {
return DeliveryResult.failure(e.getMessage());
}
}
// deliverWithRetry(), deliverAsync(), canHandle() all inherited!package com.techsustainify.domain.event;
import java.time.Instant;
import java.util.UUID;
/**
* Sealed interface — all domain events in the Order bounded context.
* Enables exhaustive pattern matching in event handlers.
* Permitted types are immutable records.
*/
public sealed interface OrderDomainEvent
permits OrderDomainEvent.OrderPlaced,
OrderDomainEvent.OrderConfirmed,
OrderDomainEvent.OrderShipped,
OrderDomainEvent.OrderDelivered,
OrderDomainEvent.OrderCancelled {
// Common contract for all events
String orderId();
String eventId();
Instant occurredAt();
default String getEventType() {
return getClass().getSimpleName();
}
// ── PERMITTED RECORDS — each is final by nature ───
record OrderPlaced(
String orderId,
String customerId,
double totalAmount,
String eventId,
Instant occurredAt
) implements OrderDomainEvent {
public OrderPlaced(String orderId, String customerId, double total) {
this(orderId, customerId, total,
UUID.randomUUID().toString(), Instant.now());
}
}
record OrderConfirmed(
String orderId,
String confirmedBy,
String eventId,
Instant occurredAt
) implements OrderDomainEvent {
public OrderConfirmed(String orderId, String confirmedBy) {
this(orderId, confirmedBy, UUID.randomUUID().toString(), Instant.now());
}
}
record OrderShipped(
String orderId,
String trackingNumber,
String carrier,
Instant estimatedDelivery,
String eventId,
Instant occurredAt
) implements OrderDomainEvent {
public OrderShipped(String orderId, String tracking,
String carrier, Instant eta) {
this(orderId, tracking, carrier, eta,
UUID.randomUUID().toString(), Instant.now());
}
}
record OrderDelivered(
String orderId, String eventId, Instant occurredAt
) implements OrderDomainEvent {
public OrderDelivered(String orderId) {
this(orderId, UUID.randomUUID().toString(), Instant.now());
}
}
record OrderCancelled(
String orderId,
String reason,
String cancelledBy,
String eventId,
Instant occurredAt
) implements OrderDomainEvent {
public OrderCancelled(String orderId, String reason, String by) {
this(orderId, reason, by, UUID.randomUUID().toString(), Instant.now());
}
}
}
// ── EVENT HANDLER — exhaustive switch, no default ─────
public class OrderEventHandler {
public void handle(OrderDomainEvent event) {
// Compiler verifies ALL five cases are covered — no default needed!
switch (event) {
case OrderDomainEvent.OrderPlaced e ->
System.out.printf("Order placed: %s for customer %s (₹%.2f)%n",
e.orderId(), e.customerId(), e.totalAmount());
case OrderDomainEvent.OrderConfirmed e ->
System.out.printf("Order confirmed: %s by %s%n",
e.orderId(), e.confirmedBy());
case OrderDomainEvent.OrderShipped e ->
System.out.printf("Order shipped: %s via %s (track: %s)%n",
e.orderId(), e.carrier(), e.trackingNumber());
case OrderDomainEvent.OrderDelivered e ->
System.out.printf("Order delivered: %s at %s%n",
e.orderId(), e.occurredAt());
case OrderDomainEvent.OrderCancelled e ->
System.out.printf("Order cancelled: %s — Reason: %s%n",
e.orderId(), e.reason());
}
}
}Interface Flowchart — From Declaration to Runtime Dispatch
This flowchart shows the complete lifecycle of a Java interface — from declaration and implementation through to runtime polymorphic dispatch.
Code Execution Flow — from source to output
Java Interface Interview Questions — Beginner to Advanced
These questions are consistently asked in Java fresher and experienced developer interviews, campus placements, and OCPJP certification exams.
Practice Questions — Test Your Interface Knowledge
Attempt each question independently before reading the answer — active recall significantly improves retention and understanding.
1. What is the output? interface Greet { default void hello() { System.out.println("Interface hello"); }} class Base { public void hello() { System.out.println("Base hello"); }} class Child extends Base implements Greet { } public class Test { public static void main(String[] args) { new Child().hello(); } }
Easy2. Will this compile? Identify and fix all issues. interface Drawable { void draw(); static void staticHelper() { System.out.println("Static helper"); } } class Canvas implements Drawable { protected void draw() { System.out.println("Drawing"); } public void render() { Canvas.staticHelper(); } }
Easy3. Design a functional interface 'StringTransformer' that takes a String and returns a String. Use it with lambdas to: (a) uppercase, (b) reverse, (c) trim+lowercase. Then compose them.
Medium4. Two interfaces A and B both have 'default void log()'. Class C implements both. Show how to resolve the conflict — (a) using A's version, (b) using B's version, (c) writing a completely new version.
Medium5. What is wrong with this code? Fix it. interface AppConstants { String DB_URL = "jdbc:mysql://localhost:3306/app"; int MAX_CONNECTIONS = 10; String API_KEY = "secret-key-12345"; } class DatabaseService implements AppConstants { public void connect() { System.out.println("Connecting to " + DB_URL); } }
Medium6. Implement a sealed interface 'Result<T>' with two permitted records: 'Success<T>' (holds a value T) and 'Failure<T>' (holds an error message String). Write a method that uses exhaustive switch pattern matching.
Hard7. Explain why 'new Runnable() { ... }' is an anonymous class and how it relates to a lambda. Show both forms.
Hard8. Design an interface hierarchy for a payment system: PaymentGateway (base) → SecurePaymentGateway (adds encryption contract) → InternationalPaymentGateway (adds currency conversion). Show a class implementing the most derived interface.
HardConclusion — Interfaces: The Backbone of Java's Flexibility
Interfaces are the most powerful abstraction mechanism in Java. They enable programming to contracts rather than implementations — the fundamental principle behind testable, extensible, maintainable enterprise software. Every major Java framework — Spring, Hibernate, JUnit, Java EE — is built on carefully designed interface hierarchies that allow any implementation to be swapped without changing the calling code.
Modern Java interfaces are richer than ever: default methods enable API evolution and mixin-style composition; static methods provide namespace-clean factory utilities; private methods enable internal helpers without polluting the public API; functional interfaces power the entire lambda and Stream ecosystem; sealed interfaces bring algebraic data type safety to Java. Mastering interfaces is mastering Java's type system.
Your next step: Java Polymorphism — where you will see how interfaces and inheritance work together to create programs where one reference type handles many different implementations, how runtime dispatch enables extensible architectures, and how modern Java's pattern matching switch takes polymorphic dispatch to a new level of expressiveness. ☕