Fresher Drive @ 27th September Java

A final class in Java cannot be a subclass because the final keyword indicates that the class cannot be extended or inherited by any other class. It is used to prevent further modification or extension of the class. Therefore, a final class is the correct answer as it cannot be a superclass or a parent class for any other class.

The method that must be defined by a class implementing the java.lang.Runnable interface is "public void run()". This method is responsible for the actual execution of the thread when it is started. It contains the code that will be run in a separate thread of execution.

The program will fail to compile because the expression `(x = y)` is attempting to assign a double value to an int variable, which is not allowed in Java. The assignment operator `=` can only be used to assign values of the same type.

The output of the program will be "Finally". This is because the code is using a try-finally block. In this case, the try block does not have any code that will be executed, as it only contains a return statement. However, the finally block will always be executed, regardless of whether an exception is thrown or not. Therefore, "Finally" will be printed as the output of the program.

The correct answer is "interface." In Java, "interface" is a valid keyword used to define a collection of abstract methods. It is used to define a contract that a class must implement, specifying the methods that the class should have. It allows for multiple inheritance and is commonly used for achieving abstraction and loose coupling in object-oriented programming.

The keyword "interface" is a valid keyword in Java. It is used to define a collection of abstract methods that can be implemented by a class. Interfaces provide a way to achieve multiple inheritance in Java and allow classes to have common behavior without actually being related through inheritance.

A final class cannot be a subclass in Java because the final keyword is used to restrict the inheritance of a class. When a class is declared as final, it means that it cannot be extended or subclassed by any other class. This is done to prevent any further modifications or extensions to the class, ensuring that its functionality remains intact and unchanged. Therefore, a final class cannot serve as a superclass or be extended by any other class.

The output of the program will be "Finally". This is because the code inside the finally block will always execute, regardless of whether there is an exception or a return statement in the try block. In this case, the return statement will cause the program to exit the main method, but before doing so, the finally block will be executed and "Finally" will be printed.

The correct answer is "Public static short stop = 23". In an interface, all variables are by default public, static, and final. Therefore, it is valid to declare a public static short variable within an interface. The other options provided are not valid declarations within an interface.

The init() method executes only once. This method is called when the object is first created and initialized. It is typically used to initialize variables and perform any necessary setup tasks before the object is used. Once the init() method is executed, it will not be called again unless the object is re-initialized.

A static nested class is a class that is defined inside another class, but it is marked as static. This means that it can be accessed without creating an instance of the enclosing class. However, because it is static, it does not have access to the nonstatic members (variables and methods) of the enclosing class. Therefore, the statement "It does not have access to nonstatic members of the enclosing class" is true.

A static nested class is a nested class that is declared with the "static" keyword. This means that it can be accessed without creating an instance of the enclosing class. However, because it is static, it does not have access to nonstatic members (variables and methods) of the enclosing class. It can only access static members of the enclosing class. Therefore, the statement "It does not have access to nonstatic members of the enclosing class" is true.

The main method is the entry point of a Java program, and it is typically used to accept command-line arguments. By using an array as a parameter of the main method, we can pass multiple values as command-line arguments to the program. The array allows us to store and access these values easily within the program. Therefore, using an array as a parameter of the main method allows us to store multiple values effectively.

The correct answer is 1, 2, 6. The methods notify(), notifyAll(), and wait(long msecs) are methods of the Object class. These methods are used for inter-thread communication and synchronization. The method notify() wakes up a single thread that is waiting on the object's monitor, while notifyAll() wakes up all the threads that are waiting on the object's monitor. The method wait(long msecs) causes the current thread to wait until either another thread invokes the notify() method or a specified amount of time has elapsed.

Default access is the most restrictive access that allows a class to have access to members of another class in the same package. Default access, also known as package-private access, means that the members are accessible only within the same package. It restricts access from classes outside the package, providing a level of encapsulation and preventing unwanted access to the members. Public, private, and protected access modifiers have wider access scopes, allowing access from classes outside the package or subclasses, which may not be desired in this scenario.

The program uses a switch statement inside a for loop.

In the first iteration of the loop, when i is 0, the case 0 is encountered and the break statement is executed, causing the program to exit the switch statement. The program then prints "done".

In the second iteration, when i is 1, the case 1 is encountered and "one " is printed. Since there is no break statement, the program falls through to the next case. The case 2 is encountered and "two " is printed. The program then exits the switch statement and prints "done".

In the third iteration, when i is 2, the case 2 is encountered and "two " is printed. The program falls through to the next case and encounters case 3, printing "three ". The program then exits the switch statement and prints "done".

Therefore, the output of the program is "one two three two three done".

The line "int [ ][ ] scores = {2,7,6}, {9,3,45};" causes a compiler error because the array initialization is incorrect. In a two-dimensional array, each row should be enclosed in curly braces. So the correct initialization should be "int [ ][ ] scores = {{2,7,6}, {9,3,45}};".

The output will be "nullnull" because both strings "a" and "b" are declared as static variables but not initialized with any values. In Java, when a string variable is not assigned a value, its default value is null. Therefore, when we concatenate two null strings, the result will be "nullnull".

The line "int [ ][ ] scores = {2,7,6}, {9,3,45};" causes a compiler error because the syntax for initializing a 2D array is incorrect. The correct syntax for initializing a 2D array is "int[][] scores = {{2,7,6}, {9,3,45}};". The correct syntax uses double braces to enclose each row of the 2D array.

The output of the program will be "BaseBase".

This is because the class "Alpha" extends the class "Base", which means it inherits all the members of the "Base" class. When the program creates a new instance of "Alpha", it calls the constructor of the "Base" class, which prints "Base". Then, when the program creates a new instance of "Base", it again calls the constructor of the "Base" class, resulting in another "Base" being printed. Therefore, the output is "BaseBase".

The correct answer is Java.util.Map. Hashtable in Java implements the Map interface, which means it provides key-value pair storage and retrieval functionality. The Map interface allows you to store and retrieve values based on a unique key. Hashtable is a synchronized implementation of the Map interface, which means it is thread-safe and can be used in multi-threaded environments.