Java Programming and EJB Fundamentals Quiz

ejbLoad() is a valid callback method in Entity Beans that is invoked by the container to synchronize the bean's state with the underlying database. This method is part of the EJB lifecycle and is called when the container needs to refresh the entity bean's state from persistent storage.

Message-Driven Beans (MDB) in EJB cannot have local or remote interfaces because they are designed to be asynchronous message consumers. Unlike session or entity beans, MDBs are endpoint components that only implement the MessageListener interface and don't support direct client invocation.

The @PrePassivate annotation in EJB marks callback methods that must return void. These methods are invoked by the container before a stateful session bean is passivated (serialized to secondary storage), and they follow the EJB lifecycle callback convention of having no return value.

Stateful session beans in EJB experience multiple lifecycle callbacks: construction (when created), destruction (when removed), activation (when restored from passivated state), and passivation (when serialized to secondary storage). All these events are part of the stateful bean lifecycle.

The Application Assembler role in EJB is responsible for assembling application modules and can override transaction attributes in the deployment descriptor. This role sits between the Bean Provider and Deployer in the EJB application development lifecycle and has permission to modify transaction settings.

Every entity in JPA/EJB must have a primary key that uniquely identifies each persistent instance. This is a fundamental requirement of the entity specification - primary keys can be simple or composite, but an entity cannot exist without one. Option B is incorrect because primary keys are mandatory.

Entity Beans only support Container Managed Transactions (CMT) and cannot use Bean Managed Transactions (BMT). Session Beans support both CMT and BMT. Therefore, the statement that both CMT and BMT can be used with both Entity and Session Beans is false because Entity Beans are restricted to CMT only.

Stateless Session Beans have two lifecycle states: 'Does Not Exist' and 'Method-Ready'. The 'Does Not Exist' state represents when the bean instance is not associated with any client and exists in the pool. When a client invokes a business method, the bean transitions to the Method-Ready state. Unlike Stateful Session Beans, Stateless Session Beans do not have a 'Passive' state for passivation. The 'Pooled State' terminology is sometimes used colloquially but 'Does Not Exist' is the formal specification term.

EJB server clusters provide high availability through load distribution and load balancing capabilities. When multiple EJB servers are clustered, incoming requests can be distributed across the cluster, preventing any single server from becoming a bottleneck. If one server fails, requests can be routed to other servers. Location transparency (B) is provided by the EJB container itself, not specifically by clustering. Caching capability (C) is application-specific. Two-phase commit (2PC) is a transaction protocol, not a clustering benefit per se.

To solve this question, the user needs to have knowledge of Java threads, Runnable interface, and the difference between extending and implementing a class/interface.

The code snippet above creates a Thread using a Runnable target. To use this code snippet, the user needs to create a class that implements the Runnable interface. The Runnable interface has only one method, which is the run() method.

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

A. public class MyRunnable extends Runnable{public void run(){}}

This option is incorrect because the Runnable interface cannot be extended. It can only be implemented.

B. public class MyRunnable extends Object{public void run(){}}

This option is incorrect because it does not implement the Runnable interface. Instead, it extends the Object class and defines a run() method, which is not the correct implementation of the run() method from the Runnable interface.

C. public class MyRunnable implements Runnable{public void run(){}}

This option is correct. It creates a class called MyRunnable that implements the Runnable interface. It defines the run() method, which is required by the Runnable interface. Therefore, this code will compile correctly.

D. public class MyRunnable implements Runnable{void run(){}}

This option is incorrect because the run() method is missing the public access modifier. The run() method must be declared as public since it is an implementation of the run() method from the Runnable interface.

Therefore, the correct answer is:

The Answer is: C

The Scanner is initialized with the string 'hello 1 2.00 false' and uses space as delimiter. scanner.next() returns 'hello', scanner.nextInt() returns 1, scanner.nextFloat() returns 2.0 (note: when printed, float 2.00 displays as 2.0), and scanner.nextBoolean() returns false. These are concatenated with colons, producing 'hello:1:2.0:false'. No InputMismatchException occurs because the data types match the scanner method calls.

Line 5 attempts to cast a Gen to Gen. While line 4's raw type cast compiles with a warning, line 5 is a compile-time error because you cannot directly cast a parameterized type of one generic type to another. The compiler enforces type safety - Gen and Gen are incompatible types. The error occurs at compile time because generics are erased but type checking happens during compilation to ensure type safety.

When the switch expression i=9 doesn't match any case label (0, 1, or 2), execution falls through to the default case. The default case prints 'default' but has no break statement, so execution continues to the next case (case 0) which prints 'zero'. The break after case 0 stops further fallthrough. Therefore the output is 'default' followed by 'zero' on the next line.

Java enforces that overriding methods cannot be more restrictive than the method they override. This preserves the Liskov Substitution Principle - a subclass must be usable wherever its superclass is expected. Therefore, you cannot override a public method as private or protected. Static methods CAN be overloaded (B is false). Private methods CAN be overloaded within the same class (C is false). Overloaded methods (not overriding) can throw any exceptions regardless of the base class (D is false - it describes overriding, not overloading).

In Java, 'then' is NOT a keyword or reserved word. Java's conditional statement uses 'if' and 'else' - 'then' is not part of the syntax. The other options ARE keywords or reserved words: 'if' is a conditional keyword, 'goto' is a reserved word (though not used), 'while' is a loop keyword, and 'case' is used in switch statements. This question tests knowledge of Java's reserved word list.

In Java, when an array is instantiated with 'new int[5]', all elements are automatically initialized to the default value for the type. For int arrays, the default value is 0. Therefore anar[0] contains 0. The variable 'anar' is properly initialized (not null), so there's no compilation error or null reference.

When Hello.txt doesn't exist, FileInputStream throws FileNotFoundException. The catch block for FileNotFoundException executes, printing 'No such file found' and returning -1. Before returning, the finally block executes, printing 'Doing finally'. The return -1 completes after finally. Therefore output is: 'No such file found' then 'Doing finally' then the method returns -1. Note: The main method prints the return value, so we see -1 after 'Doing finally'.

The Set interface is designed specifically to store unique elements - it explicitly prohibits duplicate values. This matches the requirement of storing unique objects without sorting. List allows duplicates and maintains insertion order. Map stores key-value pairs, not just elements. Vector is a legacy List implementation that allows duplicates. Set implementations like HashSet provide uniqueness without sorting (unlike TreeSet which sorts).

The Set interface is indeed designed to store unique elements - no duplicate elements are allowed. This is its defining characteristic. Option A is false because Collection is an interface, not a class. Option B is false because the Collection interface doesn't have an 'enumerator' method - it has an 'iterator' method. Option C is false because the iterator() method returns an Iterator, not a Vector instance - Vector is a concrete class that implements List.