JAVA Interview Questions and Answers

• Java is a high-level programming language and is platform independent.

• Java is a collection of objects. It was developed by Sun Microsystems. There are a lot of applications, websites and Games that are developed using Java.

Java 12 was launched on March 19, 2019. It is a Non-LTS version. Some of the Java 12 Features are:

1. JVM Changes – JEP 189, JEP 346, JEP 344, and JEP 230.
2. Switch Expressions.
3. File mismatch() Method.
4. Compact Number Formatting.
5. Teeing Collectors in Stream API.
6. New Methods in String Class.
7. JEP 334: JVM Constants API.
8. JEP 305: Pattern Matching for instanceof.
9. Raw String Literals is Removed From JDK 12.

Java is based on Object Oriented Programming Concepts, following are some of the OOPS concepts implemented in Java programming.

• Abstraction.

• Encapsulation.

• Polymorphism.

• Inheritance.

• Association.

• Aggregation.

• Composition.

Platform independence means that you can write once and run anywhere For example, you can write Java program in Windows and run it in Mac OS.

Java is not said to be pure object-oriented because it supports primitive sorts such as int, byte, short, long etc. I believe it brings simplicity to the language while writing our code. Obviously, Java should have wrapper objects for the primitive types but just for the representation, they would no longer have supplied any benefit.

As we know, for all the primitive sorts we have wrapper classes such as Integer, Long etc that offers some additional methods.

An object consists of methods and classes that depict its state and perform operations. A Java program contains a lot of objects instructing each other their jobs. This concept is part of core Java.

Java encapsulates codes in various classes that define new data types. These new data types are used to create objects.

Overloading refers to the case of having two methods of the same name however different properties whereas overriding occurs when there are two methods of the same name and identity,however one is in the child class and the other is in the parent class.

In Java, access specifiers are the keywords used before a class name which defines the access scope. The types of access specifiers for classes are:

• Public: Class, Method, Field is accessible from anywhere.

• Protected: Method,Field can be accessed from the same class to which they belong or from the sub-classes, and from the class of same package, but not from outside.

• Default: Method,Field,class can be accessed only from the same package and not from outside of it’s native package.

• Private: Method, Field can be accessed from the same class to which they belong.

When we want to share method or variable between multiple objects of a class instead of creating separate copies for each object, we use static keyword to make a method or variable shared for all objects.

Java is not 100% Object-oriented because it makes use of eight primitive data types such as boolean, byte, char, int, float, double, long, short which are not objects.

Wrapper classes convert the Java primitives into the reference types (objects). Every primitive data type has a type dedicated to it. These are recognised as wrapper classes because they “wrap” the primitive data type into an object of that class.

Constructor refers to a block of code which is used to initialize an object.Constructor looks like same name as that of the class. Also, it has no return type and it is automatically called when an object is created.

Program compiles successfully. But at runtime throws an error “NoSuchMethodError”.

Within an instance method or a constructor, “this” is a reference to the current object — the object whose method or constructor is being called. You can refer to any member of the current object from within an instance method or a constructor by using this.

Usage of “this” keyword:

• Used to refer current class instance variable.

• To invoke current class constructor.

• It can be passed as an argument in the method call.

• It can be passed as an argument in the constructor call.

• Used to return the current class instance.

• Used to invoke current class method (implicitly).

Just–In–Time(JIT) Compiler: It is used to enhance the performance. JIT compiles parts of the byte code that have similar functionality at the identical time, and hence reduces the quantity of time needed for compilation. Here the term “compiler” refers to a translator from the instruction set of a Java virtual computer (JVM) to the instruction set of a particular CPU.

Classloader is a subsystem of JVM which is used to load class files. Whenever we run the java program, it is loaded first by the classloader. There are three built-in classloaders in Java.

• Bootstrap ClassLoader: This is the first classloader which is the superclass of Extension classloader. It loads the rt.jar file which contains all class files of Java Standard Edition like java.lang package classes, java.net package classes, java.util package classes, java.io package classes, java.sql package classes etc.

• Extension ClassLoader: This is the child classloader of Bootstrap and parent classloader of System classloader. It loads the jar files located inside $JAVA_HOME/jre/lib/ext directory.

• System / Application ClassLoader: This is the child classloader of Extension classloader. It loads the class files from the classpath. By default, the classpath is set to the current directory. You can change the classpath using “-cp” or “-classpath” switch. It is also known as Application classloader.

There are various advantages of defining packages in Java.

• Packages avoid the name clashes.
• The Package provides easier access control.
• We can also have the hidden classes that are not visible outside and used by the package.
• It is easier to locate the related classes.

The Object is the real-time entity having some state and behavior. In Java, Object is an instance of the class having the instance variables as the state of the object and the methods as the behavior of the object. The object of a class can be created by using the new keyword.

In Java, all objects are dynamically allocated on Heap. This is different from C++ where objects can be allocated memory either on Stack or on Heap. In C++, when we allocate object using new(), the object is allocated on Heap, otherwise on Stack if not global or static.

In Java, when we only declare a variable of a class type, only a reference is created (memory is not allotted for an object). To allocate memory to an object, we ought to use new(). So an object is always allotted memory on heap.

• Encapsulation is a concept in Object Oriented Programming for combining properties and methods in a single unit.

• Encapsulation helps programmers to follow a modular approach for software development as each object has its own set of methods and variables and serves its functions independent of other objects.

• Encapsulation also serves data hiding purpose.

A singleton class in Java can have only one instance and therefore all its methods and variables belong to simply one instance. Singleton class concept is useful for the situations when there is a want to limit the number of objects for a class.

The best instance of singleton usage state of affairs is when there is a limit of having only one connection to a database due to some driver boundaries or because of any licensing issues.

In Java, float takes 4 bytes in memory while Double takes 8 bytes in memory. Float is single precision floating point decimal number while Double is double precision decimal number.

Interfaces are core part of Java programming language and used a lot not only in JDK but also Java design patterns, most of the frameworks and tools. Interfaces provide a way to achieve abstraction in Java and used to define the contract for the subclasses to implement.

Interfaces are good for starting point to define Type and create top level hierarchy in our code. Since a Java class can implement multiple interfaces, it’s better to use interfaces as super class in most of the cases.

• Abstract keyword is used to create abstract class whereas interface is the keyword for interfaces.

• Abstract classes can have method implementations whereas interfaces can’t.

• A class can extend only one abstract class but it can implement multiple interfaces.

• We can run an abstract class if it has main(),whereas we can’t run an interface

A marker interface is an empty interface,but used to force some functionality in implementing classes by Java. Some of the well known marker interfaces are Serializable and Cloneable.

• Using Math.random() you can generate random numbers in the range greater than or equal to 0.1 and less than 1.0.

• Using Random class in package java.util.

• Java doesn’t use pointers because they are unsafe and increases the complexity of the program.

• Since Java is known for its simplicity of code, adding the concept of pointers will be contradicting.

• Moreover JVM is responsible for implicit memory allocation, thus in order to avoid direct access to memory by the user,pointers are discouraged in Java.

Yes. We can create an abstract class by using abstract keyword before class name even if it doesn’t have any abstract method. However, if a class has even one abstract method, it must be declared as abstract.

Based on the parameters passed in the constructors, there are two types of constructors in Java.

• Default Constructor: It is the one which does not accept any value. The default constructor is mainly used to initialize the instance variable with the default values. It can also be used for performing some useful task on object creation. A default constructor is invoked implicitly by the compiler if there is no constructor defined in the class.
• Parameterized Constructor: It is the one which can initialize the instance variables with the given values. In other words, we can say that the constructors which can accept the arguments are called parameterized constructors.

• Polymorphism means many forms.

• A single object can refer the super class or sub-class depending on the reference type which is called polymorphism.

Ordered:

It means the values that are stored in a collection is based on the values that are added to the collection. So we can iterate the values from the collection in a specific order.

Sorted:

Sorting mechanism can be applied internally or externally so that the group of objects sorted in a particular collection is based on properties of the objects.

As we know that the static context (method, block or variable) belongs to the class, not the object. Since Constructors are invoked only when the object is created, there is no sense to make the constructors static. However, if you try to do so, the compiler will show the compiler error.

In java, when a package is imported, its sub-packages aren’t imported and developer needs to import them separately if required.

For example, if a developer imports a package university.*, all classes in the package named university are loaded but no classes from the sub-package are loaded. To load the classes from its sub-package (say department), developer has to import it explicitly as follows:

• Import university.department.*

• Enum was introduced in Java 1.5 as a new type whose fields consists of fixed set of constants. For example, in Java we can create direction as enum with fixed fields as EAST, WEST, NORTH, SOUTH.

• Enum is the keyword to create an enum type and similar to the class. Enum constants are implicitly static and final.

The expansion of JSON is “JavaScript Object Notation”. It is a much lighter and readable alternative to XML. It is independent and easily parse-able in all programming languages. It is primarily used for client–server and server–server communication.

• Composition is the design technique to implement has-a relationship in classes. We can use Object composition for code reuse.

• Java composition is achieved by using instance variables that refer to other objects. The benefit of using composition is that we can control the visibility of other objects to client classes and reuse only what we need.

In java, to convert an object into byte stream by serialization, an interface with the name Serializable is implemented by the class. All objects of a class implementing serializable interface get serialized and their state is saved in byte stream.

• In Java, a local variable is typically used inside a method, constructor, or a block and has only local scope.

• Thus, this variable can be used only within the scope of a block. The best benefit of having a local variable is that other methods in the class won’t be even aware of that variable.

In Java, string objects are immutable in nature which simply means once the String object is created its state cannot be modified. Whenever you try to update the value of that object instead of updating the values of that particular object, Java creates a new string object.

Java String objects are immutable as String objects are generally cached in the String pool. Since String literals are usually shared between multiple clients, action from one client might affect the rest. It enhances security, caching, synchronization, and performance of the application. 

Holding the reference of a class within some other class is known as composition. When an object contains the other object, if the contained object cannot exist without the existence of container object, then it is called composition.

In other words, we can say that composition is the particular case of aggregation which represents a stronger relationship between two objects. Example: A class contains students. A student cannot exist without a class. There exists composition between class and students.

Aggregation represents the weak relationship whereas composition represents the strong relationship. For example, the bike has an indicator (aggregation), but the bike has an engine (composition).

Priority Queue: Linked list class has been enhanced to implement the queue interface. Queues can be handled with a linked list. Purpose of a queue is “Priority-in, Priority-out”.

Hence elements are ordered either naturally or according to the comparator. The elements ordering represents their relative priority.

• The “super” keyword in Java is a reference variable that is used to refer the immediate parent class object.

• Whenever you create the instance of the subclass, an instance of the parent class is created implicitly which is referred by super reference variable.

• The super() is called in the class constructor implicitly by the compiler if there is no “super” or “this”.

Differences between this and super keyword is listed below.

• The super keyword always points to the parent class contexts whereas this keyword always points to the current class context.
• The super keyword is primarily used for initializing the base class variables within the derived class constructor whereas this keyword primarily used to differentiate betweenlocal and instance variables when passed in the class constructor.
• The super and this must be the first statement inside constructor otherwise the compiler will throw an error.

Exception is first thrown from the method which is at the top of the stack. If it doesn’t catch, then it pops up the method and strikes to the previous method and so on till they are caught.

This is called Exception propagation.