Java Interviews MCQs

Static methods in Java can be overloaded or overridden. Overloading is the process of having two or more methods with the same name but different parameters, while overriding is the process of having two methods with the same name and same parameters. Overloading is possible for static methods in Java, as it does not depend on the object instance. On the other hand, overriding is also possible for static methods in Java, as it is based on the type of the object instance.

The main method in Java is declared as static so that it can be called without creating an instance of the class. This is because the main method is the entry point of the program and needs to be executed first when the program starts. Additionally, the main method is declared as static so that it can access static variables and methods directly without the need to create an instance of the class.

If the static modifier is removed from the main method in Java, the program will still compile and run normally. This is because the main method is the entry point of the program and the JVM will still be able to find it. However, if the main method is not declared as static, the program will not be able to access any static members of the class.

Variables in Java have scope depending on the type of variable. Local variables have scope within the block where they are declared, instance variables have scope within the class where they are defined, and class variables (static variables) have scope within the class and its subclasses. All of the above scenarios are correct.

The keyword "this" in Java refers to the current instance of the class. It is used to refer to the instance variables and methods of the current object. It can also be used to pass the current object as an argument to a method.

An abstract class is a class that cannot be instantiated and can only be inherited. It is a class that is declared with the abstract keyword and may contain both abstract and non-abstract methods. Abstract classes cannot be instantiated, and it is designed to be inherited by other classes. Abstract classes may contain static data members.

In Java, the Object class is the superclass for every class. It is the root of the class hierarchy and provides the basic functionality of all classes. It is the parent class of all other classes and provides the fundamental methods and variables that are inherited by all classes. Object class methods are clone(), equals(), finalize(), getClass(), hashCode(), notify(), notifyAll(), toString(), and wait().

The main() method can be overloaded in Java, meaning that multiple versions of the main() method can be created with different parameters. This is useful when the program needs to be executed with different sets of arguments. However, it is considered bad practice to overload the main() method as it can lead to confusion and errors.

Object cloning in Java is the process of creating an exact copy of an object. This process is done by using the clone() method of the Object class. The clone() method creates a new object with the same state as the original object. The new object is an exact copy of the original object, including all its fields and methods. The clone() method also ensures that the new object is of the same type as the original object.

In Java, multiple inheritance is supported, while in C++ it is not. This means that a class in Java can inherit from multiple classes, while in C++ a class can only inherit from one class. In addition, in Java all classes inherit from a common superclass, while in C++ they do not. Furthermore, in C++ classes can have multiple levels of inheritance, while in Java they cannot.

Method overloading in Java is not possible by changing the return type of the method because it would lead to ambiguity and confusion during method resolution. This is because the compiler would not be able to decide which method to call at runtime if two methods with the same name and different return types exist. Moreover, it would also violate the principles of object-oriented programming, as the same method name would be used for different purposes. Furthermore, Java does not support dynamic dispatch based on return types, which means that the compiler would not be able to determine the correct method to call at runtime.

Private methods in Java can be overridden but only within the same class. This is because private methods are not visible outside the class and hence cannot be accessed from any other class. Private methods can be overridden by creating a new method with the same name and parameters in the same class. The new method will override the existing private method. However, private methods cannot be overridden in a subclass.

A blank final variable is a variable that is declared with the "final" keyword and cannot be changed or reassigned once it has been initialized. It is a constant value that remains the same throughout the program.

The "super" keyword is used to invoke the superclass constructor or method in Java. It is used to access the members of the superclass that have been hidden by a subclass. It is also used to refer to the immediate superclass of a class.

A static variable in Java is a variable that is declared with the "static" keyword and cannot be changed once assigned a value. It is accessible from anywhere within the class, but not from outside the class. It is also shared among all instances of a class, meaning that any changes made to the static variable will be reflected in all instances of the class.

The main difference between HashMap and HashTable is that HashMap allows null values while HashTable does not. Additionally, HashMap is not synchronized, meaning that multiple threads can access it simultaneously, while HashTable is synchronized, meaning that only one thread can access it at a time.

Java objects are stored in a heap memory, which is a section of memory that is shared among all threads in a process. The heap memory is managed by the JVM and is used to store objects and their associated data. The heap memory is divided into two parts: the young generation and the old generation. The young generation is used to store newly created objects, while the old generation is used to store objects that have been around for a while. The JVM also uses the heap memory to store static variables and class metadata.

C++ is a powerful, general-purpose programming language that supports multiple inheritance and operator overloading, features that are not present in Java. Multiple inheritance allows a class to inherit from multiple parent classes, while operator overloading allows the same operator to be used with different types of data. These features are not present in Java, which only allows single inheritance and does not support operator overloading.