Java Core Classes and Threads

wait() is an instance method of Object class (A), must be called in synchronized context (F), and requires the calling thread to hold the object's lock (D). It's not static (B), not in Thread class (C), and multiple threads can wait on the same object (E). Three options are correct.

In Java, synchronized methods can be overridden to be non-synchronized (and vice versa) because synchronization is a property of the implementation, not the method signature. Additionally, while a thread holds a lock on a synchronized method, other threads can freely access non-synchronized methods.

When a client attempts to connect to a server that is not running, Java throws a ConnectException. This is a runtime exception indicating the connection was refused because no server is listening at the specified host and port.

The transient modifier in Java tells the JVM to skip that field during serialization - it won't be written to the persistent stream. This is useful for fields that can be recalculated, are derived from other data, contain sensitive information, or reference non-serializable objects.

When a Java program starts, the JVM creates several threads beyond the main thread, including garbage collector threads and possibly other JVM-internal threads for monitoring, JIT compilation, and other runtime services. The main thread is just one of many threads running from the beginning.

In JUnit 3, methods must start with 'test' to be recognized, but JUnit 4+ uses annotations like @Test and allows any method name. The statement is false because method naming conventions vary by framework version.

Console.readPassword() reads password input from the console with echoing disabled (characters don't appear on screen). It returns char[] not String for security (can be cleared from memory).

HashTable stores key-value pairs and allows retrieval by unique key. ArrayList is index-based, StringCollection is string-specific, and NameValueCollection exists but isn't the primary key-access collection.

Session.Abandon() explicitly ends and cleans up the current user session. Session.Clear() empties session data but keeps the session alive, and Session.Dispose() isn't a standard session method.

MQGET API requires input parameters: Object Handle (Hobj), Buffer (to receive message), Buffer Length (size of buffer), and Connection Handle (Hconn). The 'Length of application data in message' is an OUTPUT parameter (returned in the DataLength field) that tells you how much data was actually retrieved, not an input you provide.

MQCMIT API commits all operations within the current unit of work. Its parameters are: Connection Handle (Hconn), Completion Code (CompCode), and Reason Code (Reason). Object Handle (Hobj) is NOT a parameter for MQCMIT because commit operations work at the connection/transaction level, not on individual queue objects.

In Java, the synchronized modifier is not part of a method's signature. This means a subclass can override a synchronized method and choose whether to keep or remove the synchronized keyword. The synchronization is an implementation detail, not a contract that must be preserved.

Valid main method signatures must be public static void with a single String array or varargs parameter. Modifier order (static public vs public static) is flexible. Parameter names can be any valid identifier. Return type must be void, and only one String array/varargs parameter is allowed.

In Java, checked exceptions are subclasses of Exception but are not subclasses of RuntimeException. Subclasses of Error and RuntimeException are unchecked.