Master Java Interview Answers: From Abstract Classes to Redis Pipelines and Index Optimization

Self Introduction

During an interview, a concise self‑introduction (1‑2 minutes) should highlight your main tech stack, core strengths with concrete examples, one or two relevant projects, and optionally your enthusiasm for the role.

State your primary technology area, e.g., Java backend development, distributed systems.

Emphasize a key strength with a brief example (e.g., solved a performance bottleneck, improved a metric).

Briefly mention 1‑2 projects or achievements that align with the job.

If time permits, express genuine interest in the position and the company.

Project Highlights Using the B‑T‑A‑R Model

When presenting a project, use the B‑T‑A‑R framework to keep the story clear and impactful.

Background : Explain what the project does and why it matters.

Task/Challenge : Describe the toughest technical or business problem faced.

Action : Detail analysis, solution design, implementation steps, and how challenges were overcome.

Result : Quantify the impact with data (e.g., response time reduced from 2 s to 200 ms, throughput increased threefold) and note any additional benefits.

Difference Between Abstract Classes and Interfaces

Design purpose : Interfaces define behavior contracts; abstract classes enable code reuse and express an “is‑a” relationship.

Inheritance : A class can extend only one class (including an abstract class) but can implement multiple interfaces.

Member variables : Interface fields are public static final constants; abstract class fields can have any access modifier.

Methods : Before Java 8, interface methods were implicitly public abstract. Since Java 8, interfaces can have default and static methods; Java 9 added private methods. Abstract classes can contain both abstract and concrete methods.

public interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

public interface MyInterface {
    static void staticMethod() {
        System.out.println("This is a static method in the interface.");
    }
}

Purpose of Java Varargs

Since Java 5, varargs allow a method to accept an arbitrary number of arguments, simplifying API design and avoiding cumbersome overloads or array parameters. The varargs parameter must be the last in the method signature.

public static void method1(String... args) {
    // ...
}

public static void method2(String arg1, String... args) {
    // ...
}

Varargs are compiled into an array, providing a clean, flexible way to handle multiple inputs.

Pros and Cons of Database Indexes

Advantages

Significantly speeds up query retrieval by reducing scanned rows.

Ensures data uniqueness when using unique indexes.

Accelerates ORDER BY and GROUP BY operations by leveraging the index’s sorted order.

Disadvantages

Index creation and maintenance add overhead, especially on DML operations.

Indexes consume additional storage space.

Poorly designed or unused indexes can degrade performance.

When Indexes Improve Query Performance

Columns frequently used in WHERE clauses with high selectivity.

Columns used for ORDER BY or GROUP BY.

Foreign‑key columns frequently used in JOIN conditions.

Prefer short, non‑NULL columns to keep the index lightweight.

Redis: Pipeline vs Lua Script

To reduce network round‑trips when sending many commands, Redis offers pipelines (batching commands) and Lua scripts (atomic batch execution). Pipelines send a batch of commands in one request, improving throughput but not providing atomicity. Lua scripts execute as a single atomic command, allowing conditional logic and command dependencies.

Cache Breakdown Issue

Cache breakdown occurs when hot data expires from the cache, causing a sudden surge of database requests that can overwhelm the DB.

Never‑expire (not recommended) – set a long TTL for hot data.

Pre‑warm the cache (recommended) – load hot data before traffic spikes.

Use a mutex lock on cache miss – ensure only one request repopulates the cache.

Distributed Session Consistency

Storing sessions in a distributed cache such as Redis or Memcached allows all application servers to share session state, offering high performance, easy horizontal scaling, and simple integration.

Advantages : In‑memory speed, easy scaling, strong framework support.

Disadvantages : Potential data loss if the cache fails without proper persistence, and added operational complexity.

Excel Export OOM Solutions

Out‑of‑Memory errors during large Excel exports stem from loading all data into memory. Stream‑oriented libraries avoid this.

Use Alibaba’s EasyExcel (or FastExcel) for “read‑write” streaming with minimal memory footprint.

If using Apache POI, employ SXSSFWorkbook to keep only a sliding window of rows in memory.

Paginate database queries and write rows incrementally.

Export only required columns.

Consider asynchronous export via a task queue (Kafka, RabbitMQ) and notify users upon completion.