Java

A virtual machine that runs bytecode, so the same compiled output runs anywhere a JVM exists.

It also optimises while running - inlining hot methods and compiling interpreted code to native instructions based on what the program actually does.

What it is really testing. Whether you mention run-time optimisation rather than only portability.

The JIT compiler has not yet identified and optimised the hot paths.

Benchmarking the first second measures the interpreter rather than the program, which is why warm-up matters in any Java measurement.

What it is really testing. Whether you know to warm up before measuring.

The JVM runs bytecode, the JRE adds the standard library, the JDK adds the compiler and tools.

You need the JDK to build and historically only the JRE to run, though modern distributions have largely merged them.

What it is really testing. Whether you can separate the three rather than using them interchangeably.

A primitive holds a value directly; a wrapper is an object that can be null and used in collections.

Autoboxing hides the conversion, which is why an Integer compared with == can be false for equal values above the cache range.

What it is really testing. Whether you know autoboxing exists and what it hides.

== compares references, and only small values are cached as shared objects.

Values from -128 to 127 are cached so == appears to work, then stops at 128. Always use equals for wrapper comparison.

What it is really testing. Whether you know about the integer cache. It is a classic trick question.

String is immutable, StringBuilder is mutable and fast, StringBuffer is the synchronised and slower variant.

Building a string in a loop with concatenation creates a new object each time, which is quadratic. StringBuilder is the fix.

What it is really testing. Whether you know loop concatenation is quadratic.

For safety in the string pool, for hashing, and so they can be shared across threads without locks.

Because they are cached in a pool, a mutable String could change a value another part of the program relies on.

What it is really testing. Whether you can give more than one reason.

Equal objects must return the same hash code; unequal objects may collide.

Break it and an object stored in a HashMap becomes unfindable, with no error raised - the map still holds it but lookup goes to the wrong bucket.

What it is really testing. Whether you can name the failure - a lost map entry with no exception.

If the mutation changes the hash code, the entry becomes unreachable.

This is the practical argument for immutable keys, and one reason records are a useful addition to the language.

What it is really testing. Whether you connect it to the argument for immutable keys.

An abstract class may hold state and partial implementation; an interface declares a contract.

Java allows one superclass and many interfaces, which often decides it. Interfaces can now have default methods, which narrowed the gap.

What it is really testing. Whether you know default methods narrowed the difference.

So callers depend on a contract rather than an implementation, and the implementation can be substituted.

It is what makes code testable without a mocking framework - any object satisfying the interface can be passed in.

What it is really testing. Whether you connect it to testability rather than treating it as theory.

Passing dependencies in rather than constructing them - and no, a constructor parameter is enough.

A framework only automates the wiring. A class that builds its own database connection cannot be tested in isolation.

What it is really testing. Whether you separate the pattern from the framework.

Failures the compiler forces you to catch or declare.

The intent was sound, but declarations propagate through layers that do not care, and people wrap everything in catch blocks that log and continue.

What it is really testing. Whether you can argue both sides. No language since has copied it.

Error signals a serious JVM problem, Exception an anticipated failure, RuntimeException an unchecked programming error.

Catching Error is almost always wrong. Catching Throwable catches both and should be rare and deliberate.

What it is really testing. Whether you know which ones you should not catch.

It closes resources automatically at the end of the block, even if it throws.

It replaced nested finally blocks and removes the possibility of forgetting, which was a steady source of connection leaks.

What it is really testing. Whether you know what it replaced and why that mattered.

ArrayList has fast indexed access and cheap appends; LinkedList has cheap insertion once positioned.

LinkedList is almost never the right choice in practice, because chasing pointers defeats the CPU cache badly enough to lose even where theory favours it.

What it is really testing. Whether you mention cache behaviour. The textbook answer alone is incomplete.

Keys are hashed to a bucket; collisions are chained, and long chains become a balanced tree.

The treeification was added so that adversarial hash collisions degrade to logarithmic rather than linear lookup.

What it is really testing. Whether you know about treeification, which is a relatively recent change.

HashMap has no ordering, LinkedHashMap keeps insertion order, TreeMap keeps keys sorted.

TreeMap costs logarithmic time for the ordering. Choosing by what you need to iterate rather than by habit is the point.

What it is really testing. Whether you choose by required ordering rather than by habit.

Fail-fast throws if the collection is modified during iteration; fail-safe iterates a copy.

Most standard collections are fail-fast, which turns a subtle concurrency bug into an immediate exception.

What it is really testing. Whether you know most standard collections are fail-fast.

Generics give collections a type at compile time; erasure removes the parameter before run time.

So you cannot create an array of a generic type or check instanceof against one. It was done for backwards compatibility.

What it is really testing. Whether you know erasure explains the restrictions rather than them being arbitrary.

extends means read-only producer, super means write-only consumer.

The mnemonic is producer-extends, consumer-super. A list of extends Number can be read as Number but not added to.

What it is really testing. Whether you can state the producer-consumer mnemonic and apply it.

== compares references; equals compares value, if the class overrides it.

A class that does not override equals inherits reference comparison, which is why two equal-looking objects can be unequal.

What it is really testing. Whether you know the default inherited behaviour.

When one thread's writes become visible to another.

Without synchronisation or volatile there is no guarantee a change is ever seen, because of caching and reordering - not just interleaving.

What it is really testing. Whether you mention visibility rather than only interleaving.

It guarantees visibility of writes across threads and prevents certain reorderings.

It does not make compound operations atomic, so a volatile counter increment is still a race.

What it is really testing. Whether you know it does not make increments atomic.

synchronized is simpler and scoped to a block; a Lock allows timeouts, interruption and multiple conditions.

Most code should use neither directly - the concurrent collections and executors in the standard library are usually the right level.

What it is really testing. Whether you recommend the higher-level tools instead of either.

Running tasks on a managed thread pool rather than creating threads by hand.

Creating a thread per task exhausts memory at scale, because each traditional thread reserves about a megabyte of stack.

What it is really testing. Whether you know why thread-per-task does not scale.

Lightweight threads managed by the JVM, cheap enough to create in millions.

They make the simple blocking style viable again at scale, which removes much of the motivation for reactive programming.

What it is really testing. Whether you know they change the economics of blocking code.

A collection holds elements; a stream describes a computation over them and is consumed once.

Streams are lazy, so nothing happens until a terminal operation, and a stream cannot be reused after that.

What it is really testing. Whether you know a stream is single-use.

For small collections, or where the work per element is tiny.

Coordination overhead frequently costs more than the parallelism saves, and the shared pool can be starved by a blocking operation.

What it is really testing. Whether you can name a case where it is slower.

Expressing that a return value may be absent - misused as a field or a parameter type.

As a field it adds a wrapper without adding information and breaks serialisation. Calling get without checking defeats the purpose entirely.

What it is really testing. Whether you know the misuses. Advocating it everywhere is a weaker answer.

A concise class for data that generates its constructor, accessors, equals, hashCode and toString.

It removes about sixty lines of boilerplate whose equals and hashCode were frequently written incorrectly.

What it is really testing. Whether you know what it generates and why that matters.

Restricting which types may implement it, so the compiler knows the complete set.

Combined with pattern matching in switch it allows exhaustiveness checking, which is how you model a closed set of states.

What it is really testing. Whether you connect it to exhaustive pattern matching.

final prevents reassignment or overriding, finally always runs, finalize was a deprecated cleanup hook.

finalize is removed in practice - it had unpredictable timing and is replaced by try-with-resources and cleaners.

What it is really testing. Whether you know finalize is effectively gone.

It belongs to the class rather than an instance - and it is a problem when it holds state or reaches outside.

A static method that touches a database or a clock cannot be substituted in a test, which is the usual cause of untestable classes.

What it is really testing. Whether you connect static to testability.

An inner class holds a reference to its enclosing instance; a static nested class does not.

That hidden reference can keep a large object alive, which is a classic subtle memory leak.

What it is really testing. Whether you know the hidden enclosing reference can leak memory.

Unreachable objects are reclaimed; generational collectors assume most objects die young.

You rarely tune it directly, but knowing the generational assumption explains why allocating many short-lived objects is cheaper than it sounds.

What it is really testing. Whether you know the generational assumption and what follows from it.

Holding references you no longer need - caches, listeners, static collections, ThreadLocals.

The collector only frees what is unreachable, so a forgotten entry in a static map is a leak the language cannot help with.

What it is really testing. Whether you can name a concrete source rather than saying it cannot happen.

A shallow copy shares nested objects; a deep copy duplicates them.

Clone is shallow by default and its contract is awkward enough that copy constructors or factory methods are usually preferred.

What it is really testing. Whether you know clone is shallow and awkwardly specified.

They pull transitive dependencies, so your application contains libraries you never chose.

Running a dependency audit is a five-minute task most teams skip, and it is the highest-value security habit in the ecosystem.

What it is really testing. Whether you have ever run an audit. Most candidates have not.

Good for large, long-lived systems maintained by teams; poor for short scripts and start-up-sensitive workloads.

The verbosity people complain about is the price of the explicitness that makes year eight survivable. Native compilation has narrowed the start-up gap.

What it is really testing. Whether you can name where it is a poor fit rather than advocating uncritically.