Java Programming Fundamentals Quiz

In Java, a try block can exist without catch if it has a finally block. This pattern is useful for resource cleanup or code that must execute regardless of exceptions.

In Java's exception hierarchy, Throwable is the base class for all throwable objects. Exception inherits directly from Throwable, while Error is a separate subclass of Throwable for serious system errors that applications typically shouldn't catch.

StackOverflowError and OutOfMemoryError are both subclasses of java.lang.Error, not Exception. Errors represent serious problems that applications should not typically catch - they indicate JVM-level issues rather than application logic problems.

After an exception is handled and no references to the exception object remain, it becomes eligible for garbage collection like any other dereferenced Java object. It does not remain permanently on the stack.

NullPointerException extends RuntimeException, making it an unchecked exception. This means developers aren't required to catch or declare it - it typically indicates programming errors like attempting to use a null reference where an object is required.

Java's HashMap allows a single null key and multiple null values. This is a standard and frequently tested feature of the Java Collections Framework.

Class.forName is used to load classes dynamically at runtime by passing their fully qualified name as a string. It is a fundamental mechanism for dynamic class loading in Java.

In object oriented programming, inheritance represents an is-a relationship, which is synonymous with generalization. A subclass generalizes or specializes an existing superclass.

An abstract method cannot be declared as final in Java because abstract methods are meant to be overridden in subclasses, whereas final methods cannot be overridden. Thus, this combination causes a compilation error.

Java is strictly pass-by-value. When passing objects, Java passes the reference by value - meaning you get a copy of the reference, not the original reference itself. This prevents methods from changing what the original variable points to. You can modify the object's state, but you cannot make the caller's variable reference a different object. Java has no true pass-by-reference semantics.

In Java, the String class is declared as final, which prevents any class from extending it. Therefore, you cannot inherit from or extend the String class.

The transient keyword in Java is used to indicate that a field should not be serialized when the class instance is converted into a byte stream. During deserialization, transient variables are initialized with their default values (e.g., null for objects, 0 for integers).

In Java, this() is a special syntax used inside a constructor to invoke another overloaded constructor within the same class (constructor chaining). It must be the first statement in the constructor. It does not instantiate new objects directly or call subclass constructors.

Once a Java thread completes its execution (exits its run() method) or is terminated, its state becomes 'TERMINATED' (dead). In JVM, you cannot restart a dead thread; attempting to call start() on it again will throw an IllegalThreadStateException.

The Factory Pattern is classified as a creational design pattern because it provides an interface for creating objects without specifying their exact classes. It delegates object instantiation to subclasses or factory methods, promoting loose coupling by letting code depend on abstractions rather than concrete implementations. This is in contrast to structural patterns like composite or behavioral patterns like command.

In Java, the assignment operator (=) is right-associative, meaning expressions are evaluated from right to left. This allows chained assignments like a = b = c, which is parsed as a = (b = c). Most other Java operators including +, >>, and << are left-associative. Right associativity is rare in Java and is limited primarily to the assignment operator.

StringBuffer is synchronized (thread-safe) while StringBuilder is not. Both classes are mutable - they can be modified after creation. StringBuilder is faster when you don't need thread safety.

A Thread can be created either by extending the Thread class or by implementing the Runnable interface. Option A is wrong because Thread is a class, not an interface. Option D is wrong - we can and do create Threads programmatically.