Java MCQ

Explanation

JVM stands for Java Virtual Machine, the runtime environment that executes Java bytecode on any platform.

Explanation

String is a class in Java, not a primitive type. Java's eight primitives are byte, short, int, long, float, double, boolean, and char.

Explanation

The JVM looks for public static void main(String[] args) as the entry point. All modifiers — public, static, and the void return type — are required.

Explanation

The new keyword allocates memory for a new object and calls its constructor.

Explanation

Instance variables of type int are automatically initialized to 0 if no value is assigned.

Explanation

In Java, // starts a single-line comment. /* ... */ is used for multi-line comments.

Explanation

The extends keyword creates a subclass that inherits fields and methods from a superclass.

Explanation

A class uses implements to fulfill the contract defined by an interface.

Explanation

Every Java class implicitly extends java.lang.Object, which provides methods like toString(), equals(), and hashCode().

Explanation

A final variable can only be assigned once; attempting to reassign it causes a compile-time error.

Explanation

In Java, int is always 32 bits (4 bytes) regardless of the underlying platform, unlike C/C++.

Explanation

A constructor has the same name as the class, no return type, and is called automatically when an object is created with new.

Explanation

Method overloading allows the same method name with different parameter lists, enabling compile-time polymorphism.

Explanation

private restricts access to within the declaring class only; it is the most restrictive access modifier.

Explanation

Static methods belong to the class itself and can be called without creating an instance, e.g., Math.sqrt().

Explanation

java.lang is implicitly imported in every Java file, providing core classes like String, Math, System, and Object.

Explanation

Integer division in Java truncates the decimal part, so 10 / 3 yields 3, not 3.33.

Explanation

A do-while loop checks its condition after executing the body, ensuring the body runs at least once.

Explanation

instanceof returns true if the object on the left is an instance of the class or interface on the right.

Explanation

An abstract class is declared with the abstract keyword and cannot be instantiated. It may contain abstract methods that subclasses must implement.

Explanation

System.out.println() writes text followed by a newline to the standard output stream.

Explanation

Instance boolean variables default to false when not explicitly initialized.

Explanation

Java identifiers must start with a letter, underscore, or dollar sign. _myVar is valid; 2count starts with a digit, class is a keyword, and my-var contains a hyphen.

Explanation

A Java array is a fixed-length data structure that holds elements of the same type, accessed by index starting at 0.

Explanation

JDK (Java Development Kit) includes the compiler (javac), JRE, and tools needed to develop Java applications.

Explanation

== compares primitive values or object references for equality. For object content comparison, use equals().

Explanation

byte is an 8-bit signed integer with a range of -128 to 127.

Explanation

Overriding occurs when a subclass provides its own implementation of an inherited method with the same signature.

Explanation

ArrayList implements List and allows duplicates, maintaining the order elements were inserted.

Explanation

void indicates that a method does not return any value.

Explanation

Declaring a class final prevents inheritance. For example, String is a final class.

Explanation

The ternary operator takes three operands: a condition, a value if true, and a value if false, all in one expression.

Explanation

ArrayIndexOutOfBoundsException is thrown when code tries to access an array element at a negative index or an index >= array.length.

Explanation

Java uses static final (by convention in ALL_CAPS) to declare constants. const is a reserved word but not used.

Explanation

String.length() returns the number of characters in the string. Note: arrays use .length (property), but String uses .length() (method).

Explanation

Autoboxing automatically converts a primitive (e.g., int) to its wrapper (Integer) when needed, and unboxing does the reverse.

Explanation

In Java, arrays are declared with [] and allocated with new type[size].

Explanation

this refers to the current object instance and is used to distinguish instance variables from local variables with the same name.

Explanation

When a String is added to an int, Java concatenates them. "5" + 3 produces "53".

Explanation

Exception is the superclass of all checked exceptions. RuntimeException (unchecked) and Error also extend Throwable.

Explanation

super() calls the parent constructor, and super.method() calls an overridden method in the parent class.

Explanation

== compares memory addresses (references) while equals() compares the actual character sequences. Two distinct String objects with the same content are == false but equals() true.

Explanation

try contains code that might throw, catch handles specific exceptions, and finally always executes — useful for cleanup like closing streams.

Explanation

ArrayList offers O(1) indexed access but O(n) insert/delete. LinkedList offers O(1) insert/delete at ends but O(n) random access.

Explanation

Checked exceptions (e.g., IOException) must be either caught or declared in the method signature with throws, enforced by the compiler.

Explanation

synchronized acquires a monitor lock on the object (or class), preventing concurrent access and race conditions.

Explanation

An interface defines a contract. Since Java 8, interfaces can also include default and static methods with implementations.

Explanation

HashMap uses hashing for O(1) average performance but no order. TreeMap uses a Red-Black Tree, keeping keys sorted but at O(log n) cost.

Explanation

Lambda expressions (e.g., (x) -> x * 2) provide a concise way to implement functional interfaces, enabling functional programming patterns.

Explanation

volatile ensures that reads and writes go directly to main memory, preventing threads from caching a stale value, but does not provide atomicity for compound operations.

Explanation

Runnable has a single abstract method run() which defines the code that runs in the new thread.

Explanation

Optional<T> forces callers to handle the absent-value case explicitly, reducing NullPointerExceptions.

Explanation

The Stream API enables declarative data processing with operations like filter, map, reduce, and collect, optionally in parallel.

Explanation

Java supports multiple interface implementation but single class inheritance. Abstract classes can have constructors, state, and concrete methods.

Explanation

@Override is a compile-time check. If the annotated method doesn't actually override a parent method, the compiler reports an error.

Explanation

throw new SomeException() is the statement that raises an exception. throws in a method signature tells callers which checked exceptions the method may propagate.

Explanation

The contract says: if a.equals(b) is true, then a.hashCode() == b.hashCode(). The reverse is not required; different objects can share a hash code (collision).

Explanation

The JVM's garbage collector identifies objects with no live references and frees their memory, so developers don't need to manually deallocate.

Explanation

Implementing Comparable<T> and its compareTo() method defines the natural ordering used by Collections.sort() and TreeSet.

Explanation

intern() checks the string pool; if an equal string exists, it returns the pooled reference. This allows == comparison for interned strings.

Explanation

final modifies classes/methods/variables. finally is a block that always runs after try-catch. finalize() is a deprecated method called by GC before object cleanup.

Explanation

A functional interface (annotated with @FunctionalInterface) has exactly one abstract method. Examples: Runnable, Callable, Comparator, and the java.util.function types.

Explanation

unmodifiableList wraps a list so that add/remove/set throw UnsupportedOperationException. The underlying list can still be mutated through the original reference.

Explanation

Fields marked transient are skipped during Java serialization, useful for sensitive data or non-serializable objects.

Explanation

ListIterator extends Iterator with hasPrevious(), previous(), add(), and set(), enabling bidirectional traversal and modification.

Explanation

Java requires more specific exceptions to be caught before broader ones. Placing a parent type first makes child-type catch blocks unreachable, which is a compile-time error.

Explanation

Method chaining (fluent interface) returns this from each method, enabling patterns like StringBuilder.append("a").append("b").toString().

Explanation

Java's Arrays.sort() and Collections.sort() use TimSort, a hybrid stable sorting algorithm derived from merge sort and insertion sort.

Explanation

Executor and ExecutorService provide thread pool management, reducing overhead of creating new threads for each task.

Explanation

Deadlock occurs when Thread A holds lock X and waits for lock Y, while Thread B holds lock Y and waits for lock X — both block forever.

Explanation

StringBuffer methods are synchronized, making it thread-safe but slower. StringBuilder is unsynchronized and preferred for single-threaded string manipulation.

Explanation

Singleton restricts instantiation to one object, typically using a private constructor and a static getInstance() method.

Explanation

Iterable<T> requires implementing iterator(), which the enhanced for loop calls. Collections like ArrayList implement it.

Explanation

volatile ensures visibility but not atomicity for compound operations. AtomicInteger uses CPU compare-and-swap (CAS) for lock-free atomic increments and conditional updates.

Explanation

parseInt(String s, int radix) parses the string in the given base. "10" in base 2 equals 2 in decimal.

Explanation

LinkedHashMap extends HashMap and uses a doubly-linked list to maintain the insertion-order of entries.

Explanation

Default methods allow new methods to be added to interfaces without breaking existing implementations.

Explanation

Concatenating with + in a loop creates O(n^2) String objects. StringBuilder.append() is O(n). String.format() is convenient but allocates more than direct StringBuilder use.

Explanation

java.util.concurrent provides ExecutorService, ConcurrentHashMap, CountDownLatch, Semaphore, LinkedBlockingQueue, and much more for robust multithreaded programming.

Explanation

try (InputStream in = new FileInputStream(f)) { } automatically calls in.close() on exit, equivalent to a manual finally block but more concise and correct.

Explanation

The JMM defines happens-before relationships, ensuring developers can reason about visibility and ordering across threads when using synchronization, volatile, and locks.

Explanation

Phantom references are used for pre-mortem cleanup. PhantomReference.get() always returns null; you detect collection via the ReferenceQueue.

Explanation

G1 (Garbage First) divides the heap into equal-size regions and targets a maximum pause time set via -XX:MaxGCPauseMillis, balancing throughput and low latency.

Explanation

Without volatile, the JIT can reorder writes so another thread sees a partially constructed object. volatile establishes a happens-before, making DCL safe.

Explanation

ClassLoader.loadClass() loads but does not initialize (no static blocks run). Class.forName(name, true, loader) initializes by default, running static initializers.

Explanation

Frameworks like AspectJ, Mockito, and many APM agents use bytecode instrumentation (via java.lang.instrument or ASM) to inject code without modifying source.

Explanation

ForkJoinPool implements work-stealing: idle threads steal tasks from busy threads' deques, maximizing CPU utilization for RecursiveTask/RecursiveAction workloads.

Explanation

If the JIT proves an object never escapes a method, it may allocate the object on the stack (avoiding GC) or elide unnecessary locks, boosting performance.

Explanation

Introduced in Java 7, invokedynamic defers method linkage to a bootstrap method at runtime. Java 8 lambdas are desugared to invokedynamic calls, enabling efficient functional constructs.

Explanation

Each method call pushes a frame onto the thread stack. Infinite or too-deep recursion exhausts the stack space, throwing StackOverflowError (an Error, not Exception).

Explanation

Virtual threads (JEP 444, GA in Java 21) are cheap, JVM-scheduled threads. Millions can exist simultaneously, unblocking blocking I/O calls without consuming OS threads.

Explanation

WeakReference objects are eligible for collection as soon as no strong references exist. SoftReference objects are kept alive until the JVM needs memory, making them suitable for caches.

Explanation

The JMM's happens-before relation (§17.4.5) defines when one action's results are guaranteed visible to another — established by synchronized, volatile, thread start/join, etc.

Explanation

Inlining is the JIT's most impactful optimization. It removes call overhead and exposes the inlined code to further optimizations like constant folding and escape analysis.

Explanation

Java agents use Instrumentation.addTransformer() to hook into class loading and modify bytecode before the class is defined, powering APM tools, coverage agents, and mocking frameworks.

Explanation

A sealed class uses permits to explicitly list subclasses. This enables exhaustive pattern matching and makes class hierarchies easier to reason about.

Explanation

Records (GA in Java 16) reduce boilerplate for simple data carriers. Their components are final and exposed as accessor methods matching the component name.

Explanation

Effective Java (Bloch) advises using checked exceptions for conditions a caller can reasonably recover from and runtime exceptions for programming errors or precondition violations.

Explanation

CompletableFuture (Java 8) enables asynchronous pipelines with thenApply, thenCompose, whenComplete, etc. Future.get() blocks the calling thread until completion.

Explanation

The JPMS (introduced in Java 9) encapsulates internals. --add-opens module/package=ALL-UNNAMED grants reflective access, commonly needed for legacy frameworks that rely on internal APIs.