Core Java MCQ Practice Questions

Yes, there can be an abstract class with no abstract methods in it. An abstract class is a class that cannot be instantiated and is meant to be subclassed. It can have both abstract and non-abstract methods. Even if there are no abstract methods in the abstract class, it can still serve as a base class for other classes and provide common functionality or attributes.

The program will output "Finally". The code inside the try block contains a return statement, which will cause the program to exit the main method. However, before the program exits, the finally block is executed, which prints "Finally" to the console. Therefore, the output of the program is "Finally".

Final methods in Java cannot be overridden by subclasses. Once a method is declared as final in a superclass, it cannot be modified or overridden in any of its subclasses. However, final methods can still be overloaded. Overloading refers to the concept of having multiple methods with the same name but different parameters. So, even though a final method cannot be overridden, it can still be overloaded in order to provide different implementations based on the parameters.

When the program is run, the value of j is 1. The expression (j>1) evaluates to false, so the value of i is assigned as 1. Then, the switch statement checks the value of i. Since i is 1, the case 1 is matched and the statement System.out.println(1) is executed. However, there is no break statement after this case, so the program continues to execute the next case. In this case, the statement System.out.println(2) is executed. Therefore, the output of the program will be 1 and 2.

The correct answer is java.util.Map. The Map interface in Java provides the capability to store objects using a key-value pair. It allows you to associate a unique key with a value, and you can retrieve the value by using the key. This interface is commonly used when you need to store and retrieve data based on a specific identifier or key.

In this code, the variable s1 is initially assigned the value "withoutbook". Then, the variable s2 is assigned the value of s1, which is "withoutbook". After that, s1 is set to null. Finally, the values of s1 and s2 are printed, which are "null" and "withoutbook" respectively. Therefore, the correct answer is "s1:null s2:withoutbook".

The correct answer is "start();". This method is used to start the execution of a thread. When this method is called, the thread's run() method is invoked, and the thread begins executing concurrently with the main thread. The init() method is used for initializing an applet, run() method is the entry point for a thread, and yield() is used to pause the execution of the current thread and give a chance to other threads to execute.

The program will output "ABCdef".
The variable 's' is initially assigned the value "ABC". The method 'toLowerCase()' is called on 's', which converts the string to lowercase. However, since strings are immutable in Java, the original value of 's' is not modified. The concatenation operator '+=' is then used to append the string "def" to 's'. Finally, 's' is printed, resulting in the output "ABCdef".

When the code is compiled and run, the following will be printed: 0, 3, and 4.

This is because the code enters the try block and encounters the line "if(i/j > 1)". Since j is equal to 0, an ArithmeticException is thrown. The catch block for ArithmeticException is executed, printing 0.

After the catch block, the finally block is executed, printing 3.

Finally, the line "System.out.println(4)" is executed, printing 4.

The code initializes two variables, i and x, with the values 0 and 10 respectively. The while loop will continue as long as x is greater than 6. Inside the loop, the code prints the value of i incremented by 1, followed by a space. Then, it decrements the value of x by 1. This process repeats until x becomes less than or equal to 6. Therefore, the output of the code will be "1 2 3 4".

The output of the code will be "Child method". This is because the main method in the Child class is creating an instance of the Child class and assigning it to a reference variable of the Parent class. When the method() is called on this reference variable, it will invoke the method() defined in the Child class, which prints "Child method".

The output of the program will be "A" and "C". In the first if statement, the equals() method is used to compare the object o with the string s. Since they have the same value, the condition is true and "A" is printed. In the second if statement, the equals() method is used to compare the string s with the object o. Again, they have the same value, so the condition is true and "C" is printed.

A LinkedHashMap in Java allows you to associate elements with key values, just like a HashMap. However, it also maintains the order of insertion, which means that you can retrieve the objects in the same order they were added, making it suitable for implementing a FIFO sequence. This is different from ArrayList, which is not designed for key-value associations, and HashMap and TreeMap, which do not guarantee the insertion order.

The output of the program is "TRUE" because the condition inside the if statement is assigning the value of true to the variable var. Since the assignment is successful, the condition evaluates to true and the code inside the if block is executed, which prints "TRUE" to the console.

The code snippet provided multiplies the value of the variable b by 2. However, since b is declared as a byte, which is a primitive data type in Java that can only store values from -128 to 127, the result of the multiplication exceeds the range of a byte. This causes an overflow and the value of b becomes -56 instead of 100. Therefore, the correct answer is False.

The correct answer is "Prints false" because the default value for a boolean variable is false if it is not explicitly initialized. In this case, the boolean variable "isRaining" is not initialized, so its default value of false is printed.

The program will result in a compilation error. The reason for this is that the variable "x" is not initialized before it is used in the catch1() method and in the main method. In Java, local variables must be initialized before they can be used. Therefore, the code will not compile successfully.

The output of the program will be "third second first aryabhatta 420". This is because the program creates an instance of the Arizona class in the main method. When this instance is created, the constructor with no arguments is called. This constructor then calls the constructor with a String argument, which in turn calls the constructor with an int and a String argument. Each constructor prints "third", "second", and "first" respectively. Finally, the main method prints the name and id of the instance, which are "aryabhatta" and 420 respectively.

The program starts with the string "newspaper". The substring method is used to extract a portion of the string, starting from index 5 and ending at index 7. This results in the string "ape". The charAt method is then used to retrieve the character at index 1 of the substring, which is 'p'. The string "a" is then concatenated with the character 'p', resulting in the string "app". Finally, the string "app" is printed as the output.

Bytecodes make Java platform-independent because they are the intermediate representation of Java source code that can be executed on any platform that has a Java Virtual Machine (JVM). The JVM interprets the bytecodes and translates them into machine code that is specific to the underlying operating system and hardware. This allows Java programs to run on any platform that has a JVM installed, without the need for recompilation or modification.

The program will throw an Error in the badMethod() method. Since the Error is not caught in the catch block, it will be caught in the finally block. Therefore, the output will be "C" before exiting with an error message.

The output of this code will be "XYZ ABC".

In the main method, an object of type ABC is created and assigned to a variable of type XYZ. When this object is created, the constructor of ABC is called. The constructor of ABC calls the constructor of XYZ using the "super" keyword. The constructor of XYZ then prints "XYZ".

After the constructor of XYZ is called, the constructor of ABC continues executing and prints "ABC".

There is no output of "Alphabet" because the method with the same name is actually a constructor, not a regular method, and constructors do not have a return type.

The program creates a Float object f1 with the value "3.0". It then uses the intValue(), byteValue(), and doubleValue() methods to convert the Float object to an int, byte, and double respectively. Finally, it prints the sum of x (int), b (byte), and d (double), which is 9.0. There is no NumberFormatException thrown, so the catch block is not executed. Therefore, the correct answer is 9.0.

An interface can not extend any number of interfaces. This means that an interface cannot inherit from multiple interfaces. In Java, a class can implement multiple interfaces, but an interface itself can only extend a single interface.

The correct answer is "for( a = 0 ; a