Core Java MCQ Basics Questions

Final methods in Java cannot be overridden by subclasses. When a method is declared as final, it means that it cannot be modified or overridden by any subclass. However, final methods can still be overloaded, which means that multiple methods with the same name but different parameters can exist in the same class. Overloading allows for different versions of the method to be called depending on the arguments passed to it. Therefore, the statement that final methods cannot be overridden but overloaded is true.

The correct answers are 1 and 2. When the program is run, the value of j is 1, so the value of i is set to 1. The switch statement then checks the value of i. Since i is 1, the case 1 statement is executed and "1" is printed. However, there is no break statement after the case 1 statement, so the program continues to the next case. Since i is 1, the case 2 statement is also executed and "2" is printed. Therefore, the output of the program is "1 2".

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 contain both abstract and non-abstract methods. While abstract methods are meant to be overridden by subclasses, non-abstract methods can have their own implementation. So, it is possible for an abstract class to have only non-abstract methods and no abstract methods.

The code snippet declares a static boolean variable "isRaining" but does not initialize it. In Java, boolean variables are automatically initialized to false if no value is assigned to them. Therefore, when the main method is called and the code prints the value of "isRaining", it will output false.

The code initializes a variable s1 with the value "withoutbook" and then assigns the same value to variable s2. After that, s1 is set to null. When the code prints the values of s1 and s2, it will show s1 as null and s2 as "withoutbook". This is because s2 is a separate variable that holds the value "withoutbook" and is not affected by the null assignment to s1.

The output of this code will be "Child method". This is because the main method creates an instance of the Child class and assigns it to a variable of type Parent. When the method() is called on this variable, it calls the method defined in the Child class, overriding the method defined in the Parent class. Therefore, the "Child method" is printed to the console.

Bytecodes are the compiled code instructions that can be executed by the Java Virtual Machine (JVM). The JVM is responsible for interpreting and executing these bytecodes, allowing Java programs to run on any platform that has a JVM installed. This makes Java platform-independent because the same bytecode can be executed on different operating systems without the need for recompilation. Therefore, bytecodes are what make Java programs portable and able to run on any system that supports the JVM.

The interface that provides the capability to store objects using a key-value pair is java.util.Map. This interface allows us to associate a unique key with a value, and then retrieve the value using the key. It does not allow duplicate keys, ensuring that each key is unique within the map. Additionally, the Map interface provides various methods to manipulate and access the key-value pairs, such as adding, removing, and updating entries.

The output of the program will be "A" and "C". This is because the "equals" method in Java compares the content of the objects, and since the content of both "o" and "s" is "hello", both comparisons will return true. Therefore, the program will print "A" and "C".

The code initializes two variables, i with a value of 0 and x with a value of 10. The while loop condition checks if x is greater than 6. Since x is initially 10, the condition is true and the loop is executed. Inside the loop, the value of i is incremented by 1 and printed, followed by a space. Then, the value of x is decremented by 1. This process continues until x becomes 6. Therefore, the loop will run 4 times, printing the values of i (1, 2, 3, 4) followed by a space each time. Thus, the correct answer is 1 2 3 4.

The code will not print "b = 100" because the expression "b = b * 2" will result in a compilation error. This is because the result of the multiplication operation is an int, and it cannot be automatically converted to a byte without an explicit cast. To fix this, the code should be written as "b = (byte) (b * 2)" to explicitly cast the result to a byte.

A LinkedHashMap in Java is a collection class that allows you to associate its elements with key values. It also maintains the order of insertion, allowing you to retrieve objects in FIFO (first-in, first-out) sequence. This means that elements will be returned in the same order they were added to the LinkedHashMap. Therefore, java.util.LinkedHashMap is the correct answer for this question.

The program creates an object of the class Arizona and calls the default constructor. The default constructor then calls the constructor with a String parameter, passing "aryabhatta". The constructor with a String parameter then calls the constructor with an int and a String parameter, passing 420 and "aryabhatta". Finally, the constructor with an int and a String parameter initializes the id and name variables and prints "third".

In the main method, the name and id variables of the Arizona object are printed, which are "aryabhatta" and 420 respectively. Therefore, the output of the program will be "third second first aryabhatta 420".

The correct answer is "start();". In Java, the start() method is used to start the execution of a thread. When start() is called, it creates a new thread and invokes the run() method of that thread. The run() method contains the code that will be executed by the thread. Calling the start() method allows the thread to run concurrently with other threads in the program.

The correct answer is "Prints TRUE". In the if statement, the condition is var = true, which is an assignment statement. The value of var is set to true, and since the assignment statement returns the assigned value, the condition is true. Therefore, the code inside the if block is executed, and "TRUE" is printed.

The program first assigns the substring of "newspaper" starting from index 5 and ending at index 7 to the variable 'a'. This results in 'a' being assigned the value "ap". Then, the character at index 1 of 'a' is assigned to the variable 'b', which is 'p'. Next, 'b' is concatenated to 'a', resulting in 'a' being assigned the value "app". Finally, the program prints the value of 'a', which is "app".

The output of this code will be "XYZ ABC". The code creates an object of class ABC, which is a subclass of XYZ. When the object is created, the constructor of class ABC is called, which in turn calls the constructor of class XYZ using the "super" keyword. The constructor of class XYZ then prints "XYZ". Finally, the main method prints "ABC". There is no output for "Alphabet" because the method in class Alphabet is mistakenly named "Alphabet" instead of being a constructor.

The program will output "ABCdef".


The variable "s" is initially assigned the value "ABC". The method "toLowerCase()" is called on "s", which converts all the characters in "s" to lowercase. However, the return value of "toLowerCase()" is not assigned to any variable, so the original value of "s" remains unchanged.
Then, the string "def" is concatenated to "s" using the "+=" operator, resulting in "ABCdef".
Finally, the value of "s" is printed using the "println()" method, which outputs "ABCdef" to the console.

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

The program will output "Finally". In the main method, a try block is present with a return statement. However, before the return statement is executed, the finally block is always executed. Therefore, "Finally" will be printed to the console.

The code will throw an ArithmeticException because of the line "if(i/j > 1)" where j is equal to 0. Since the catch block for ArithmeticException is present, it will execute and print 0. After the catch block, the code will execute the finally block and print 3. Finally, it will print 4. Therefore, the output will be 0 3 4.

The program will result in a compilation error. This is because the variable 'x' is not initialized before it is used in the catch1() method and the main method. Therefore, the compiler will throw an error indicating that the variable 'x' may not have been initialized.

The program throws an Error in the badMethod() method. Since the Error is not caught by a catch block for Error, it is propagated to the calling method. The catch block for Exception does not catch Errors, so it is skipped. However, the finally block is always executed, so "C" is printed before the program exits with an error message.

An interface can not extend any number of interfaces means that an interface cannot inherit from multiple interfaces. In Java, a class can implement multiple interfaces, but an interface itself can only extend one interface. This is because interfaces are used to define a contract for classes to implement, and allowing an interface to extend multiple interfaces would create ambiguity and make it difficult to enforce the contract. Therefore, an interface can only extend one interface, if any.

The program creates a Float object f1 with the value "3.0". The intValue() method is then called on f1, which returns the integer value 3. The byteValue() method is called next, which returns the byte value 3. The doubleValue() method is called last, which returns the double value 3.0. The sum of x, b, and d is then printed, which is 9.0. Since there is no NumberFormatException thrown, the catch block is not executed. Therefore, the output of the program will be 9.0.