Java Interview Questions Pdf Free Download
Do you have what it takes to ace a Java Interview? We are here to help you in consolidating your knowledge and concepts in Java. The following article will cover all the popular Java interview questions for freshers as well as experienced candidates in depth.
Go through all the questions to enhance your chances of performing well in the interviews. The questions will revolve around the basic and core fundamentals of Java.
So, let's dive deep into the plethora of useful interview questions on Java.
Java Basic Interview Questions
1. Why is Java a platform independent language?
Java language was developed in such a way that it does not depend on any hardware or software due to the fact that the compiler compiles the code and then converts it to platform-independent byte code which can be run on multiple systems.
- The only condition to run that byte code is for the machine to have a runtime environment (JRE) installed in it.
2. Why is Java not a pure object oriented language?
Java supports primitive data types - byte, boolean, char, short, int, float, long, and double and hence it is not a pure object-oriented language.
3. Pointers are used in C/ C++. Why does Java not make use of pointers?
Pointers are quite complicated and unsafe to use by beginner programmers. Java focuses on code simplicity, and the usage of pointers can make it challenging. Pointer utilization can also cause potential errors. Moreover, security is also compromised if pointers are used because the users can directly access memory with the help of pointers.
Thus, a certain level of abstraction is furnished by not including pointers in Java. Moreover, the usage of pointers can make the procedure of garbage collection quite slow and erroneous. Java makes use of references as these cannot be manipulated, unlike pointers.
4. What do you understand by an instance variable and a local variable?
Instance variables are those variables that are accessible by all the methods in the class. They are declared outside the methods and inside the class. These variables describe the properties of an object and remain bound to it at any cost.
All the objects of the class will have their copy of the variables for utilization. If any modification is done on these variables, then only that instance will be impacted by it, and all other class instances continue to remain unaffected.
Example:
class Athlete { public String athleteName; public double athleteSpeed; public int athleteAge; } Local variables are those variables present within a block, function, or constructor and can be accessed only inside them. The utilization of the variable is restricted to the block scope. Whenever a local variable is declared inside a method, the other class methods don't have any knowledge about the local variable.
Example:
public void athlete () { String athleteName; double athleteSpeed; int athleteAge; } 
5. What do you mean by data encapsulation?
- Data Encapsulation is an Object-Oriented Programming concept of hiding the data attributes and their behaviors in a single unit.
- It helps developers to follow modularity while developing software by ensuring that each object is independent of other objects by having its own methods, attributes, and functionalities.
- It is used for the security of the private properties of an object and hence serves the purpose of data hiding.
6. Tell us something about JIT compiler.
- JIT stands for Just-In-Time and it is used for improving the performance during run time. It does the task of compiling parts of byte code having similar functionality at the same time thereby reducing the amount of compilation time for the code to run.
- The compiler is nothing but a translator of source code to machine-executable code. But what is special about the JIT compiler? Let us see how it works:
- First, the Java source code (.java) conversion to byte code (.class) occurs with the help of the javac compiler.
- Then, the .class files are loaded at run time by JVM and with the help of an interpreter, these are converted to machine understandable code.
- JIT compiler is a part of JVM. When the JIT compiler is enabled, the JVM analyzes the method calls in the .class files and compiles them to get more efficient and native code. It also ensures that the prioritized method calls are optimized.
- Once the above step is done, the JVM executes the optimized code directly instead of interpreting the code again. This increases the performance and speed of the execution.
7. Can you tell the difference between equals() method and equality operator (==) in Java?
| equals() | == |
|---|---|
| This is a method defined in the Object class. | It is a binary operator in Java. |
| This method is used for checking the equality of contents between two objects as per the specified business logic. | This operator is used for comparing addresses (or references), i.e checks if both the objects are pointing to the same memory location. |
Note:
- In the cases where the equals method is not overridden in a class, then the class uses the default implementation of the equals method that is closest to the parent class.
- Object class is considered as the parent class of all the java classes. The implementation of the equals method in the Object class uses the == operator to compare two objects. This default implementation can be overridden as per the business logic.
8. How is an infinite loop declared in Java?
Infinite loops are those loops that run infinitely without any breaking conditions. Some examples of consciously declaring infinite loop is:
- Using For Loop:
for (;;) { // Business logic // Any break logic } - Using while loop:
while(true){ // Business logic // Any break logic } - Using do-while loop:
do{ // Business logic // Any break logic }while(true); 9. Briefly explain the concept of constructor overloading
Constructor overloading is the process of creating multiple constructors in the class consisting of the same name with a difference in the constructor parameters. Depending upon the number of parameters and their corresponding types, distinguishing of the different types of constructors is done by the compiler.
class Hospital { int variable1, variable2; double variable3; public Hospital (int doctors, int nurses) { variable1 = doctors; variable2 = nurses; } public Hospital (int doctors) { variable1 = doctors; } public Hospital (double salaries) { variable3 = salaries } } 
Three constructors are defined here but they differ on the basis of parameter type and their numbers.
10. Comment on method overloading and overriding by citing relevant examples.
In Java, method overloading is made possible by introducing different methods in the same class consisting of the same name. Still, all the functions differ in the number or type of parameters. It takes place inside a class and enhances program readability.
The only difference in the return type of the method does not promote method overloading. The following example will furnish you with a clear picture of it.
class OverloadingHelp { public int findarea (int l, int b) { int var1; var1 = l * b; return var1; } public int findarea (int l, int b, int h) { int var2; var2 = l * b * h; return var2; } } 
Both the functions have the same name but differ in the number of arguments. The first method calculates the area of the rectangle, whereas the second method calculates the area of a cuboid.
Method overriding is the concept in which two methods having the same method signature are present in two different classes in which an inheritance relationship is present. A particular method implementation (already present in the base class) is possible for the derived class by using method overriding.
Let's give a look at this example:
class HumanBeing { public int walk (int distance, int time) { int speed = distance / time; return speed; } } class Athlete extends HumanBeing { public int walk (int distance, int time) { int speed = distance / time; speed = speed * 2; return speed; } } 
Both class methods have the name walk and the same parameters, distance, and time. If the derived class method is called, then the base class method walk gets overridden by that of the derived class.
11. A single try block and multiple catch blocks can co-exist in a Java Program. Explain.
Yes, multiple catch blocks can exist but specific approaches should come prior to the general approach because only the first catch block satisfying the catch condition is executed. The given code illustrates the same:
public class MultipleCatch { public static void main (String args[]) { try { int n = 1000, x = 0; int arr[] = new int[n]; for (int i = 0; i <= n; i++) { arr[i] = i / x; } } catch (ArrayIndexOutOfBoundsException exception) { System.out.println("1st block = ArrayIndexOutOfBoundsException"); } catch (ArithmeticException exception) { System.out.println("2nd block = ArithmeticException"); } catch (Exception exception) { System.out.println("3rd block = Exception"); } } } Here, the second catch block will be executed because of division by 0 (i / x). In case x was greater than 0 then the first catch block will execute because for loop runs till i = n and array index are till n-1.
12. Explain the use of final keyword in variable, method and class.
In Java, the final keyword is used as defining something as constant /final and represents the non-access modifier.
- final variable:
- When a variable is declared as final in Java, the value can't be modified once it has been assigned.
- If any value has not been assigned to that variable, then it can be assigned only by the constructor of the class.
- final method:
- A method declared as final cannot be overridden by its children's classes.
- A constructor cannot be marked as final because whenever a class is inherited, the constructors are not inherited. Hence, marking it final doesn't make sense. Java throws compilation error saying -
modifier final not allowed here
- final class:
- No classes can be inherited from the class declared as final. But that final class can extend other classes for its usage.
13. Do final, finally and finalize keywords have the same function?
All three keywords have their own utility while programming.
Final: If any restriction is required for classes, variables, or methods, the final keyword comes in handy. Inheritance of a final class and overriding of a final method is restricted by the use of the final keyword. The variable value becomes fixed after incorporating the final keyword. Example:
final int a=100; a = 0; // error The second statement will throw an error.
Finally: It is the block present in a program where all the codes written inside it get executed irrespective of handling of exceptions. Example:
try { int variable = 5; } catch (Exception exception) { System.out.println("Exception occurred"); } finally { System.out.println("Execution of finally block"); } Finalize: Prior to the garbage collection of an object, the finalize method is called so that the clean-up activity is implemented. Example:
public static void main (String[] args) { String example = new String("InterviewBit"); example = null; System.gc(); // Garbage collector called } public void finalize () { // Finalize called } 14. When can you use super keyword?
- The super keyword is used to access hidden fields and overridden methods or attributes of the parent class.
- Following are the cases when this keyword can be used:
- Accessing data members of parent class when the member names of the class and its child subclasses are same.
- To call the default and parameterized constructor of the parent class inside the child class.
- Accessing the parent class methods when the child classes have overridden them.
- The following example demonstrates all 3 cases when a super keyword is used.
public class Parent { protected int num = 1; Parent(){ System.out.println("Parent class default constructor."); } Parent(String x){ System.out.println("Parent class parameterised constructor."); } public void foo () { System.out.println("Parent class foo!"); } } public class Child extends Parent { private int num = 2; Child(){ System.out.println("Child class default Constructor"); super(); // to call default parent constructor super("Call Parent"); // to call parameterised constructor. } void printNum () { System.out.println(num); System.out.println(super.num); //prints the value of num of parent class } @Override public void foo () { System.out.println("Parent class foo!"); super.foo(); //Calls foo method of Parent class inside the Overriden foo method of Child class. } } 15. Can the static methods be overloaded?
Yes! There can be two or more static methods in a class with the same name but differing input parameters.
16. Can the static methods be overridden?
- No! Declaration of static methods having the same signature can be done in the subclass but run time polymorphism can not take place in such cases.
- Overriding or dynamic polymorphism occurs during the runtime, but the static methods are loaded and looked up at the compile time statically. Hence, these methods cant be overridden.
17. What is the main objective of garbage collection?
The main objective of this process is to free up the memory space occupied by the unnecessary and unreachable objects during the Java program execution by deleting those unreachable objects.
- This ensures that the memory resource is used efficiently, but it provides no guarantee that there would be sufficient memory for the program execution.
18. What part of memory - Stack or Heap - is cleaned in garbage collection process?
Heap.
Java Advanced Interview Questions
41. Although inheritance is a popular OOPs concept, it is less advantageous than composition. Explain.
Inheritance lags behind composition in the following scenarios:
- Multiple-inheritance is not possible in Java. Classes can only extend from one superclass. In cases where multiple functionalities are required, for example - to read and write information into the file, the pattern of composition is preferred. The writer, as well as reader functionalities, can be made use of by considering them as the private members.
- Composition assists in attaining high flexibility and prevents breaking of encapsulation.
- Unit testing is possible with composition and not inheritance. When a developer wants to test a class composing a different class, then Mock Object can be created for signifying the composed class to facilitate testing. This technique is not possible with the help of inheritance as the derived class cannot be tested without the help of the superclass in inheritance.
- The loosely coupled nature of composition is preferable over the tightly coupled nature of inheritance.
Let's take an example:
package comparison; public class Top { public int start () { return 0; } } class Bottom extends Top { public int stop () { return 0; } } In the above example, inheritance is followed. Now, some modifications are done to the Top class like this:
public class Top { public int start () { return 0; } public void stop () { } } If the new implementation of the Top class is followed, a compile-time error is bound to occur in the Bottom class. Incompatible return type is there for the Top.stop() function. Changes have to be made to either the Top or the Bottom class to ensure compatibility. However, the composition technique can be utilized to solve the given problem:
class Bottom { Top par = new Top(); public int stop () { par.start(); par.stop(); return 0; } } 42. How is the creation of a String using new() different from that of a literal?
When a String is formed as a literal with the assistance of an assignment operator, it makes its way into the String constant pool so that String Interning can take place. This same object in the heap will be referenced by a different String if the content is the same for both of them.
public bool checking () { String first = "InterviewBit"; String second = "InterviewBit"; if (first == second) return true; else return false; } The checking() function will return true as the same content is referenced by both the variables.
Conversely, when a String formation takes place with the help of a new() operator, interning does not take place. The object gets created in the heap memory even if the same content object is present.
public bool checking () { String first = new String("InterviewBit"); String second = new String("InterviewBit"); if (first == second) return true; else return false; } The checking() function will return false as the same content is not referenced by both the variables.
43. Is exceeding the memory limit possible in a program despite having a garbage collector?
Yes, it is possible for the program to go out of memory in spite of the presence of a garbage collector. Garbage collection assists in recognizing and eliminating those objects which are not required in the program anymore, in order to free up the resources used by them.
In a program, if an object is unreachable, then the execution of garbage collection takes place with respect to that object. If the amount of memory required for creating a new object is not sufficient, then memory is released for those objects which are no longer in the scope with the help of a garbage collector. The memory limit is exceeded for the program when the memory released is not enough for creating new objects.
Moreover, exhaustion of the heap memory takes place if objects are created in such a manner that they remain in the scope and consume memory. The developer should make sure to dereference the object after its work is accomplished. Although the garbage collector endeavors its level best to reclaim memory as much as possible, memory limits can still be exceeded.
Let's take a look at the following example:
List<String> example = new LinkedList<String>(); while(true){ example.add(new String("Memory Limit Exceeded")); } 44. Why is synchronization necessary? Explain with the help of a relevant example.
Concurrent execution of different processes is made possible by synchronization. When a particular resource is shared between many threads, situations may arise in which multiple threads require the same shared resource.
Synchronization assists in resolving the issue and the resource is shared by a single thread at a time. Let's take an example to understand it more clearly. For example, you have a URL and you have to find out the number of requests made to it. Two simultaneous requests can make the count erratic.
No synchronization:
package anonymous; public class Counting { private int increase_counter; public int increase () { increase_counter = increase_counter + 1; return increase_counter; } } 
If a thread Thread1 views the count as 10, it will be increased by 1 to 11. Simultaneously, if another thread Thread2 views the count as 10, it will be increased by 1 to 11. Thus, inconsistency in count values takes place because the expected final value is 12 but the actual final value we get will be 11.
Now, the function increase() is made synchronized so that simultaneous accessing cannot take place.
With synchronization:
package anonymous; public class Counting { private int increase_counter; public synchronized int increase () { increase_counter = increase_counter + 1; return increase_counter; } } 
If a thread Thread1 views the count as 10, it will be increased by 1 to 11, then the thread Thread2 will view the count as 11, it will be increased by 1 to 12. Thus, consistency in count values takes place.
45. In the given code below, what is the significance of ... ?
public void fooBarMethod (String... variables) { // method code } - Ability to provide
...is a feature called varargs (variable arguments) which was introduced as part of Java 5. - The function having
...in the above example indicates that it can receive multiple arguments of the datatype String. - For example, the fooBarMethod can be called in multiple ways and we can still have one method to process the data as shown below:
fooBarMethod("foo", "bar"); fooBarMethod("foo", "bar", "boo"); fooBarMethod(new String[]{"foo", "var", "boo"}); public void myMethod (String... variables) { for(String variable : variables){ // business logic } } 46. Can you explain the Java thread lifecycle?
Java thread life cycle is as follows:
- New – When the instance of the thread is created and the start() method has not been invoked, the thread is considered to be alive and hence in the NEW state.
- Runnable – Once the start() method is invoked, before the run() method is called by JVM, the thread is said to be in RUNNABLE (ready to run) state. This state can also be entered from the Waiting or Sleeping state of the thread.
- Running – When the run() method has been invoked and the thread starts its execution, the thread is said to be in a RUNNING state.
- Non-Runnable (Blocked/Waiting) – When the thread is not able to run despite the fact of its aliveness, the thread is said to be in a NON-RUNNABLE state. Ideally, after some time of its aliveness, the thread should go to a runnable state.
- A thread is said to be in a Blocked state if it wants to enter synchronized code but it is unable to as another thread is operating in that synchronized block on the same object. The first thread has to wait until the other thread exits the synchronized block.
- A thread is said to be in a Waiting state if it is waiting for the signal to execute from another thread, i.e it waits for work until the signal is received.
- Terminated – Once the run() method execution is completed, the thread is said to enter the TERMINATED step and is considered to not be alive.
The following flowchart clearly explains the lifecycle of the thread in Java.
47. What could be the tradeoff between the usage of an unordered array versus the usage of an ordered array?
- The main advantage of having an ordered array is the reduced search time complexity of
O(log n)whereas the time complexity in an unordered array isO(n). - The main drawback of the ordered array is its increased insertion time which is O(n) due to the fact that its element has to reordered to maintain the order of array during every insertion whereas the time complexity in the unordered array is only O(1).
- Considering the above 2 key points and depending on what kind of scenario a developer requires, the appropriate data structure can be used for implementation.
48. Is it possible to import the same class or package twice in Java and what happens to it during runtime?
It is possible to import a class or package more than once, however, it is redundant because the JVM internally loads the package or class only once.
49. In case a package has sub packages, will it suffice to import only the main package? e.g. Does importing of com.myMainPackage.* also import com.myMainPackage.mySubPackage.*?
This is a big NO. We need to understand that the importing of the sub-packages of a package needs to be done explicitly. Importing the parent package only results in the import of the classes within it and not the contents of its child/sub-packages.
50. Will the finally block be executed if the code System.exit(0) is written at the end of try block?
NO. The control of the program post System.exit(0) is immediately gone and the program gets terminated which is why the finally block never gets executed.
51. What do you understand by marker interfaces in Java?
Marker interfaces, also known as tagging interfaces are those interfaces that have no methods and constants defined in them. They are there for helping the compiler and JVM to get run time-related information regarding the objects.
52. Explain the term "Double Brace Initialisation" in Java?
This is a convenient means of initializing any collections in Java. Consider the below example.
import java.util.HashSet; import java.util.Set; public class IBDoubleBraceDemo { public static void main (String[] args) { Set<String> stringSets = new HashSet<String>() { { add("set1"); add("set2"); add("set3"); } }; doSomething(stringSets); } private static void doSomething (Set<String> stringSets) { System.out.println(stringSets); } } In the above example, we see that the stringSets were initialized by using double braces.
- The first brace does the task of creating an anonymous inner class that has the capability of accessing the parent class's behavior. In our example, we are creating the subclass of HashSet so that it can use the add() method of HashSet.
- The second braces do the task of initializing the instances.
Care should be taken while initializing through this method as the method involves the creation of anonymous inner classes which can cause problems during the garbage collection or serialization processes and may also result in memory leaks.
53. Why is it said that the length() method of String class doesn't return accurate results?
- The length method returns the number of Unicode units of the String. Let's understand what Unicode units are and what is the confusion below.
- We know that Java uses UTF-16 for String representation. With this Unicode, we need to understand the below two Unicode related terms:
- Code Point: This represents an integer denoting a character in the code space.
- Code Unit: This is a bit sequence used for encoding the code points. In order to do this, one or more units might be required for representing a code point.
- Under the UTF-16 scheme, the code points were divided logically into 17 planes and the first plane was called the Basic Multilingual Plane (BMP). The BMP has classic characters - U+0000 to U+FFFF. The rest of the characters- U+10000 to U+10FFFF were termed as the supplementary characters as they were contained in the remaining planes.
- The code points from the first plane are encoded using one 16-bit code unit
- The code points from the remaining planes are encoded using two code units.
Now if a string contained supplementary characters, the length function would count that as 2 units and the result of the length() function would not be as per what is expected.
In other words, if there is 1 supplementary character of 2 units, the length of that SINGLE character is considered to be TWO - Notice the inaccuracy here? As per the java documentation, it is expected, but as per the real logic, it is inaccurate.
54. What is the output of the below code and why?
public class InterviewBit { public static void main (String[] args) { System.out.println('b' + 'i' + 't'); } } "bit" would have been the result printed if the letters were used in double-quotes (or the string literals). But the question has the character literals (single quotes) being used which is why concatenation wouldn't occur. The corresponding ASCII values of each character would be added and the result of that sum would be printed.
The ASCII values of 'b', 'i', 't' are:
- 'b' = 98
- 'i' = 105
- 't' = 116
98 + 105 + 116 = 319
Hence 319 would be printed.
55. What are the possible ways of making object eligible for garbage collection (GC) in Java?
First Approach: Set the object references to null once the object creation purpose is served.
public class IBGarbageCollect { public static void main (String [] args) { String s1 = "Some String"; // s1 referencing String object - not yet eligible for GC s1 = null; // now s1 is eligible for GC } } Second Approach: Point the reference variable to another object. Doing this, the object which the reference variable was referencing before becomes eligible for GC.
public class IBGarbageCollect { public static void main (String [] args) { String s1 = "To Garbage Collect"; String s2 = "Another Object"; System.out.println(s1); // s1 is not yet eligible for GC s1 = s2; // Point s1 to other object pointed by s2 /* Here, the string object having the content "To Garbage Collect" is not referred by any reference variable. Therefore, it is eligible for GC */ } } Third Approach: Island of Isolation Approach: When 2 reference variables pointing to instances of the same class, and these variables refer to only each other and the objects pointed by these 2 variables don't have any other references, then it is said to have formed an "Island of Isolation" and these 2 objects are eligible for GC.
public class IBGarbageCollect { IBGarbageCollect ib; public static void main (String [] str) { IBGarbageCollect ibgc1 = new IBGarbageCollect(); IBGarbageCollect ibgc2 = new IBGarbageCollect(); ibgc1.ib = ibgc2; //ibgc1 points to ibgc2 ibgc2.ib = ibgc1; //ibgc2 points to ibgc1 ibgc1 = null; ibgc2 = null; /* * We see that ibgc1 and ibgc2 objects refer * to only each other and have no valid * references- these 2 objects for island of isolcation - eligible for GC */ } } Java Interview Programs
56. Check if a given string is palindrome using recursion.
/* * Java program to check if a given inputted string is palindrome or not using recursion. */ import java.util.*; public class InterviewBit { public static void main (String args[]) { Scanner s = new Scanner(System.in); String word = s.nextLine(); System.out.println("Is "+word+" palindrome? - "+isWordPalindrome(word)); } public static boolean isWordPalindrome (String word) { String reverseWord = getReverseWord(word); //if word equals its reverse, then it is a palindrome if(word.equals(reverseWord)){ return true; } return false; } public static String getReverseWord (String word) { if(word == null || word.isEmpty()){ return word; } return word.charAt(word.length()- 1) + getReverseWord(word.substring(0, word.length() - 1)); } } 57. Write a Java program to check if the two strings are anagrams.
The main idea is to validate the length of strings and then if found equal, convert the string to char array and then sort the arrays and check if both are equal.
import java.util.Arrays; import java.util.Scanner; public class InterviewBit { public static void main (String[] args) { Scanner s = new Scanner(System.in); //Input from two strings System.out.print("First String: "); String string1 = s.nextLine(); System.out.print("Second String: "); String string2 = s.nextLine(); // check for the length if(string1.length() == string2.length()) { // convert strings to char array char[] characterArray1 = string1.toCharArray(); char[] characterArray2 = string2.toCharArray(); // sort the arrays Arrays.sort(characterArray1); Arrays.sort(characterArray2); // check for equality, if found equal then anagram, else not an anagram boolean isAnagram = Arrays.equals(characterArray1, characterArray2); System.out.println("Anagram: "+ isAnagram); } } 58. Write a Java Program to find the factorial of a given number.
public class FindFactorial { public static void main (String[] args) { int num = 10; long factorialResult = 1l; for(int i = 1; i <= num; ++i) { factorialResult *= i; } System.out.println("Factorial: "+factorialResult); } } 59. Given an array of non-duplicating numbers from 1 to n where one number is missing, write an efficient java program to find that missing number.
Idea is to find the sum of n natural numbers using the formula and then finding the sum of numbers in the given array. Subtracting these two sums results in the number that is the actual missing number. This results in O(n) time complexity and O(1) space complexity.
public class IBMissingNumberProblem { public static void main (String[] args) { int[] array={4,3,8,7,5,2,6}; int missingNumber = findMissingNum(array); System.out.println("Missing Number is "+ missingNumber); } public static int findMissingNum (int[] array) { int n=array.length+1; int sumOfFirstNNums=n*(n+1)/2; int actualSumOfArr=0; for (int i = 0; i < array.length; i++) { actualSumOfArr+=array[i]; } return sumOfFirstNNums-actualSumOfArr; } } 60. Write a Java Program to check if any number is a magic number or not. A number is said to be a magic number if after doing sum of digits in each step and inturn doing sum of digits of that sum, the ultimate result (when there is only one digit left) is 1.
Example, consider the number:
- Step 1: 163 => 1+6+3 = 10
- Step 2: 10 => 1+0 = 1 => Hence 163 is a magic number
public class IBMagicNumber { public static void main (String[] args) { int num = 163; int sumOfDigits = 0; while (num > 0 || sumOfDigits > 9) { if (num == 0) { num = sumOfDigits; sumOfDigits = 0; } sumOfDigits += num % 10; num /= 10; } // If sum is 1, original number is magic number if(sumOfDigits == 1) { System.out.println("Magic number"); }else { System.out.println("Not magic number"); } } } Java interview MCQs
Posted by: rosemariewarmbrode014823.blogspot.com
Source: https://www.interviewbit.com/java-interview-questions/