Java Core Classes and Threads

In Java interfaces, methods are implicitly public and abstract. Thus, void run(); is a valid declaration. Option two is invalid because interface methods cannot be protected. Option three is invalid because static interface methods require a body. Option four is invalid because it lacks a return type.

The try-catch is mandatory because the reference type TechnoSample has a test() method declaring throws Exception, so callers must handle it. The output is 'In TechnoSampleSub' because Java invokes the subclass method at runtime due to polymorphism. The subclass method can choose not to throw exceptions since overriding methods may declare fewer exceptions than the superclass version.

The this keyword in C# refers to the current instance of the class in which it is used, allowing access to its members. Distractors like call and do are keywords reserved for other operations, while that is not a valid C# keyword for referencing the current object.

BeginInvoke() is the correct method for asynchronous delegate invocation in C#. It initiates the delegate call on a thread pool thread and returns an IAsyncResult object for tracking. Invoke() executes synchronously, while StartInvoke() and SetInvoke() are not standard C# delegate methods.

The literal 7 is of type int. Java does not perform implicit narrowing of integer arguments to match method parameters of type short or short.... Since there is no matching method that accepts int arguments, the compiler cannot resolve the call, resulting in a compilation failure.

In SAP BDC (Batch Data Communication), the Session Method is Synchronous. When a session is created and processed, it waits for the session to complete before proceeding. This is different from Call Transaction which can be Asynchronous. Session method ensures data integrity through synchronous processing.

When creating a Thread subclass, you must override the run() method which contains the code to be executed in that thread. The start() method then calls run() in a new thread of execution.

StringBuffer in Java is a mutable sequence of characters, unlike String which is immutable. This means StringBuffer objects can be modified after creation without creating new objects, making them efficient for string manipulation operations.

To answer this question, the user needs to have knowledge of Java's synchronized collections and multithreading.

Option A: Vector is a synchronized collection class, which means that multiple threads can read and write from it but only one thread can access it at a time. Therefore, unsynchronized read operations are not allowed by multiple threads in Vector.

Option B: TreeMap is not a synchronized collection class, and therefore, it does not provide thread-safety. Multiple threads can read and write to it at the same time, which means that unsynchronized read operations are allowed by multiple threads in TreeMap.

Option C: TreeSet is not a synchronized collection class, and therefore, it does not provide thread-safety. Multiple threads can read and write to it at the same time, which means that unsynchronized read operations are allowed by multiple threads in TreeSet.

Option D: HashMap is not a synchronized collection class, and therefore, it does not provide thread-safety. Multiple threads can read and write to it at the same time, which means that unsynchronized read operations are allowed by multiple threads in HashMap.

Option E: HashSet is not a synchronized collection class, and therefore, it does not provide thread-safety. Multiple threads can read and write to it at the same time, which means that unsynchronized read operations are allowed by multiple threads in HashSet.

Therefore, the answer is: A. Vector

The correct answer is:

B. False

StringBuffer objects in Java can be modified after they are created. StringBuffer is a mutable class that allows for the modification of its content. It provides various methods to append, insert, delete, and modify the character sequence it holds. Therefore, the statement "StringBuffer objects once created can not be modified" is false.

Exception handling in Java is designed to REMOVE error-processing code from the main line of a program's logic, not keep it in the main line. Try-catch blocks separate normal execution flow from error handling, improving program clarity by keeping the main logic clean and focused. The statement claims the opposite of what exception handling actually does.

Checked exceptions (like IOException) must be caught or declared in throws clause - this is enforced at compile-time. Unchecked exceptions (RuntimeException and its subclasses) do NOT require explicit handling. Checked exceptions extend Exception (not RuntimeException), while unchecked exceptions extend RuntimeException (which itself extends Exception).

By convention, exception class names should end with 'Exception' (e.g., IOException, NullPointerException), but this is not a strict requirement - it's a naming convention for clarity. Some exception types like Error and its subclasses don't follow this pattern. The statement claims it's a strict requirement, which is false - it's a convention, not a rule.

To solve the question, the user needs to know what parseInt() method does. The parseInt() method is used to convert a string to an integer. If the string argument cannot be parsed as an integer, parseInt() throws a NumberFormatException.

Now, let's go through each option and explain why it is right or wrong:

A. NumberError: There is no exception called NumberError in Java. This option is incorrect.

B. ArithmeticException: The ArithmeticException is thrown when an exceptional arithmetic condition has occurred. Since parseInt() throws a NumberFormatException, this option is incorrect.

C. RunTimeException: RuntimeException is a superclass of all classes that represent exceptional conditions that occur during the execution of Java code. Since NumberFormatException is a subclass of RuntimeException, this option is partially correct. However, the specific exception thrown by parseInt() is NumberFormatException.

D. NumberFormatException: This is the correct answer. When parseInt() gets illegal data, it throws a NumberFormatException. This exception is thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.

Therefore, the answer is: D. NumberFormatException.