Top 130+ Java Interview Questions & Answers 2020

Java Interview Questions & Answers

In this article, we have compiled the most frequently asked Java Interview Questions. These questions will give you an acquaintance with the type of questions that an interviewer might ask you during you interview for Java Programming

As a Fresher, you have either just attended an interview or planning to attend one soon. An Entry Level jobseeker looking to grow your career in software programming, you may be nervous about your upcoming interviews. All of us have those moments of panic where we blank out and might even forget what a thread is. We will simplify it for you, all you need to do it take a deep breath and check the questions that are most likely to be asked.

You can’t avoid panicking, but you can definitely prepare yourself so that when you step in that interview room. You are confident and know you can handle anything the interviewer might throw at you.

Here is a compiled list of comprehensive 24 Java Interview Questions with Answers (latest 2020) that will help you nail that confidence, and ensure you sail through the interview.

1. What all does JVM comprise of?
JVM, short for Java Virtual Machine is required by any system to run Java programs. Its architecture essentially comprises of:
● Classloader: It is a subsystem of JVM and its main function is to load class files whenever a Java program is run.
● Heap: it is the runtime data that is used for allocating objects.
● Class area: it holds the class level of each class file such as static variables, metadata, and constant run pool.
● Stack: used for storing temporary variables.
● Register: the register contains the address of the JVM instruction currently being executed
● Execution engine: the EE consists of a virtual processor, an interpreter that executes instructions after reading the bytecode, and a JIT compiler which improves performance when the rate of execution is slow.
● Java Native Interface: it acts as the communication medium for interacting with another application developed in C, C++, etc.

2. What is object-oriented programming? Is Java an object-oriented language?
Essentially, object-oriented programming is a programming paradigm that works on the concept of objects. Simply put, objects are containers – they contain data in the form of fields and code in the form of procedures. Following that logic, an object-oriented language is a language that works on objects and procedure.

Since Java utilizes 8 primitive datatypes — boolean, byte, char, int, float, long, short, double — which are not objects, Java cannot be considered a 100% object-oriented language.

3. What do you understand by Aggregation in context of Java?
Aggregation is a form of association in which each object is assigned its own lifecycle. But, there is ownership in this, and the child object cannot belong to any other parent object in any manner.

4. Name the superclass in Java.
Java.lang. All different non-primitive are inherited directly or indirectly from this class.

5. Explain the difference between ‘finally’ and ‘finalize’ in Java?
Used with the try-catch block, the ‘finally’ block is used to ensure that a particular piece of code is always executed, even if the execution is thrown by the try-catch block.

In contrast, finalize() is a special method in the object class. It is generally overridden to release system resources when garbage value is collected from the object.

6. What is an anonymous inner class? How is it different from an inner class?
Any local inner class which has no name is known as an anonymous inner class. Since it doesn’t have any name, it is impossible to create its constructor. It always either extends a class or implements an interface, and is defined and instantiated in a single statement.

A non-static nested class is called an inner class. Inner classes are associated with the objects of the class and they can access all methods and variables of the outer class.

7. What is a system class?
It is a core class in Java. Since the class is final, we cannot override its behavior through inheritance. Neither can we instantiate this class since it doesn’t provide any public constructors. Hence, all of its methods are static.

8. How to create daemon thread in Java?
We use the class setDaemon(true) to create this thread. We call this method before the start() method, else we get IllegalThreadStateException.

Job Profile for Software Developer

9. Does Java support global variables? Why/Why not?
No, Java doesn’t support global variables. This is primarily because of two reasons:
● They create collisions in the namespace.
● They break the referential transparency.

10. How is an RMI object developed?
The following steps can be taken to develop an RMI object:
● Define the interface
● Implement the interface
● Compile the interface and their implementations with the java compiler
● Compile server implementation with RMI compiler
● Run RMI registry
● Run application

11. Explain the differences between time slicing and preemptive scheduling?
In case of time slicing, a task executes for a specified time frame – also known as a slice. After that, it enters the ready queue — a pool of ‘ready’ tasks. The scheduler then picks the next task to be executed based on the priority and other factors.

Whereas under preemptive scheduling, the task with the highest priority is executed either until it enters dead or warning states or if another higher priority task comes along.

12. Garbage collector thread is what kind of a thread?
It is a daemon thread.

13. What is the lifecycle of a thread in Java?
Any thread in Java goes through the following stages in its lifecycle:
● New
● Runnable
● Running
● Non-runnable (blocked)
● Terminated

14. State the methods used during deserialization and serialization process.
ObjectInputStream.readObject
Reads the file and deserializes the object.

ObjectOuputStream.writeObject
Serialize the object and write the serialized object to a file.

15. What are volatile variables and what is their purpose?
Volatile variables are variables that always read from the main memory, and not from thread’s cache memory. These are generally used during synchronization.

16. What are wrapper classes in Java?
All primitive data types in Java have a class associated with them – known as wrapper classes. They’re known as wrapper classes because they ‘wrap’ the primitive data type into an object for the class. In short, they convert Java primitives into objects.

17. How can we make a singleton class?
By making its constructor private.

18. What are the important methods of Exception Class in Java?
● string getMessage()
● string toString()
● void printStackTrace()
● synchronized Throwable getCause()
● public StackTraceElement[] getStackTrace()

19. How can we make a thread in Java?
We can follow either of the two ways to make a thread in Java:
● By extending Thread Class

The disadvantage of this method is that we cannot extend any other classes since the thread class has already been extended.
● By implementing Runnable interface

20. Explain the differences between get() and load() methods.
The get() and load() methods have the following differences:
● get() returns null if the object is not found, whereas load() throws the ObjectNotFound exception.
● get() always returns a real object, whereas load() returns a proxy object.
● get() method always hits the database whereas load() doesn’t.
● get() should be used if you aren’t sure about the existence of an instance, whereas load() should be used if you are sure that the instance exists.

21. What is the default value of the local variables?
They aren’t initialized to any default value. Neither are primitives or object references.

22. What is Singleton in Java?
It is a class with one instance in the whole Java application. For an example java.lang.Runtime is a Singleton class. The prime objective of Singleton is to control the object creation by keeping the private constructor.

23. What is the static method?

A static method can be invoked without the need for creating an instance of a class. A static method belongs to the class rather than an object of a class. A static method can access static data member and can change the value of it.

24. What’s the exception?

Exceptions Unusual conditions during the program. This may be due to an incorrect logic written by incorrect user input or programmer.

25. In simple terms, how would you define Java?

Java is a high-level, platform-independent, object-oriented portal, and offers support with high performance for building sophisticated programs, applications, and websites. Java is a general-purpose programming language that empowers developers to build rich functionality applications with their write once run anywhere (WORA) environment. James Arthur Gosling, a computer scientist from Canada, developed Java in 1991 and is popularly known as ‘Dr Java’. Today, Java has become an essential foundation for the modern IT industry.

26. What is Java String Pool?

A String Pool in Java is a distinct place that has a pool of strings stored via the Java Heap Memory. Here, String represents a special class in Java, and string objects can be created using either a new operator or using values in double-quotes.
The String is immutable in Java, thus, making feasibility of String pool and then the further implementation via String interning concepts.

27. What is a collection class in Java? List down its methods and interfaces?

Java Collection Classes are special classes, which are exclusively used with static methods that work specifically on return collections. Java Collection by default inherit a class and have two essential features as:

  •  They support and operate with polymorphic algorithms that return new collections for every specific collection.
  • Methods in Java Collection throw a NullPointerException in case the class objects or collections have Null value. 

 These are represented and declared as Java.util.Collectionclass. 

 There are more than 60 methods, modifiers, and types of Java Collection classes. Here is a list of the topmost important methods in Java Collection Class: 

S. No. Modifier, Method, and Type Description
1. static <T> boolean addAll() This method allows the addition of specific elements to a particular collection.
2. static <T> Queue <T> asLifoQueue() This method allows the listing of the collection as Last-in-first-out (LIFO) in view.
3. static <T> int binarySearch() This method allows searching for a specific object and then returns them in a sorted list.
4. static <E> Collection<E> This method returns the dynamic view from any particular collection.
5. static <E> List <E> This method gives a return of a dynamic typesafe view from a particular list.

Here are some examples for Java Collection:
Java Collection min() Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
 	import java.util.*;  
 	public class CollectionsExample {  
 	    public static void main(String a[]){         
 	        List<Integer> list = new ArrayList<Integer>();  
 	        list.add(90);  
 	        list.add(80);  
 	        list.add(76);  
 	        list.add(58);  
 	        list.add(12);  
          System.out.println("Minimum Value element in the collection:  "+Collections.min(list));  
      }  
  } 

The output will be:

Minimum Value element in the collection: 12

Java Collection max() Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
  import java.util.*;  
  public class CollectionsExample {  
      public static void main(String a[]){         
          List<Integer> list = new ArrayList<Integer>();  
          list.add(90);  
          list.add(80);  
          list.add(76);  
          list.add(58);  
          list.add(12);  
          System.out.println("Maximum Value element in the collection:  "+Collections.max(list));  
      }  
  }

The output will be:

Maximum Value element in the collection: 90

28. What is a servlet?

Servlets are Java software components that add more capabilities to a Java server via technology, API, interface, class, or any web deployment. Servlets run specifically on Java-powered web application servers and are capable of handling complex requests from the web server. Servlets add the benefit of higher performance, robustness, scalability, portability, and ensure safety for the Java applications. 

Servlet Process or Execution:

  • This starts when a user sends a request from a web browser.
  • The web server receives and then passes this request to the specific servlet.
  • The Servlet then processes this request to get a specific response with output.
  • The Servlet then sends this response back to the web server.
  • Then the web server gets the information that the browser displays on the screen. 

 Java Servlets come with multiple classes and interfaces like GenericServlet, ServletRequest, Servlet API, HttpServlet, ServeResponse, etc.

29. What is Request Dispatcher?

In Servlet, RequestDispatcher acts as an interface for defining an object to receive requests from clients at one side and then dispatching it to particular resources on the other side (that may be a servlet, HTML, JSP). This RequestDispatcher has two methods in general: 

void forward(ServletRequest request, ServletResponse response) That allows and forwards the requests from any servlet to server resources in the form of a Servlet, HTML file, or a JSP file.
void include(ServletRequest request, ServletResponse response) That has content for a particular resource in the form of a response such as HTML file, JSP page, or a servlet.

30. What is the life-cycle of a servlet?

Servlet is a Java software component that has the main function to first take the request, then process the request, and give a response to the user in an HTML page. Here Servlet Container manages the life-cycle of a servlet. Here are the main stages:

  • Loading Servlet.
  • Then initialising the Servlet.
  • Handling the Request (invoking service method).
  • Then destroying the Servlet.

 Here is a quick diagram showing the life cycle of a Java Servlet:
Life-Cycle-Of-Servlet

Source

  • Loading Servlet

The life cycle for Servlet begins with the loading stage in the Servlet container. Servlet loads in either of the two ways with:          

    • Setting the servlet as a positive or zero integral value.
    • Secondly, this process may get delays, as the container selects the right servlet to handle the request. 

Now the containers first load the Servlet class and then build an instance via the no-argument constructor. 

  • Initialising Servlet

Next step is to use the Servlet.init(ServletConfig) method to initialise the Servlet for instance JDBC data source.

  • Handling the Request (Invoking Service Method)

Here the Servlet takes the client requests and performs the required operation using the service() method. 

  • Destroying the Servlet

Now the Servlet container destroys the servlet by performing and completing specific tasks and calling the destroy() method in the instance.

31. What are the different methods of session management in servlets?

Sessions track the user’s activity after they login to the site. Session management provides the mechanism to procure information for every independent user. Here are the four different methods for session management in the servlets:  

  • HttpSession
  • Cookies
  • URL Rewriting
  • HTML Hidden field

32. What is a JDBC Driver?

Java Database Connectivity (JDBC) here acts as a software component that allows Java applications to communicate with a database. 

JDBC drivers have the following four types in the environment:

  • JDBC-ODBC bridge driver
  • Network Protocol driver (Middleware driver)
  • Database Protocol driver (fully Java driver)
  • Native-API driver 

33. What is the JDBC Connection interface?

Connections define the sessions between the database and Java applications. JDBC Connection interface is part of the java.sql package only and provides session information for a particular database. These represent multiple SQL statements for executing and results in the context of a single connection interface. Here are the main methods for Connections interface:

  • createStatement(): To create a specific statement object for adding SQL statements to the particular database.
  • setAutoCommit(boolean status): To define the connection of a commit mode to a false or true directive. 
  • commit(): That makes all the modifications from the last commit and further releases any database presently held by the specific Connection object. 
  • rollback(): That undoes or rollbacks all the changes done in the past or current transaction and also releases the presently held database in the connection object. 
  • close(): That terminates or closes the current connection and also releases or clears the JDBC resources instantly.

34. Name the different modules of the Spring framework?

There are multiple modules in the Spring framework:

  • Web module
  • Struts module
  • Servlet module
  • Core Container module
  • Aspect-Oriented Programming (AOP)
  • Application Context module
  • MVC framework module
  • JDBC abstraction and DAO module
  • OXM module
  • Expression Language module
  • Transaction module
  • Java Messaging Service (JMS) module
  • ORM integration module 

These modules are present in groups:

spring-modules

Source

35. Explain Bean in Spring and list the different scopes of Spring bean.

Beans are one of the fundamental concepts of the Spring framework in managing structures efficiently. In a simple definition, Spring Bean represents the IoC containers that manage the object forming the backbone of applications.

Scopes of Spring Bean:

 Scopes play a crucial role in the effective use of Spring beans in the application. Scope helps us to understand the lifecycle of the Spring Bean, and they have the following types.

S. No. Scope and Description
1. Singleton – By default, Spring bean scope has a singleton scope that represents only one instance for Spring IOC container. This same object gets shared for each request.
2. Prototype – In this, a new instance will be called and created for every single bean definition, every time a request is made for a specific bean. 
3. Request – In this scope, a single bean will be called and created for every HTTP request for that specific bean. 
4. Session – This scope defines the single bean use for a life cycle in a particular global HTTP session. 
5. Global-session – This scope allows a single bean for the particular life cycle for implementing in the global HTTP session. 

 Note: Last three scopes are applicable in the web-aware Spring ApplicationContext only.

Must Read: Why Java is so popular with Developers

36. Explain the role of DispatcherServlet and ContextLoaderListener.

While configuring XML based Spring MVC configuration in web.xml file, two declarations of DispatcherServlet and ContextLoaderListener play an essential role in complementing the purpose of the framework.  

  • DispatcherServlet – 

DispatcherServlet has the primary purpose for managing incoming web requests for specific matching configured URI patterns. DispatcherServlet acts as the front controller for the core of the Spring MVC application and specifically loads the configuration file and then initialises the right beans present in that file. And when annotations are enabled, then it can also check and scan the configurations and packages for all annotated with @Repository, @Component, @Service, or @Controller. 

  • ContextLoaderListener – 

ContextLoaderListener here acts as the request listener for starting and shutting down root WebApplicationContext. So, it creates and shares the root application context with child contexts by the DispatcherServlet contexts. Applications can only use one entry for the ContextLoaderListener in the web.xml.

37. Explain Hibernate architecture.

Hibernate defines a layered architecture that empowers users to operate and perform without knowing the underlying APIs, i.e., Hibernate acts as a framework to build and develop persistence logic independent from the Database software. 

Hibernate architecture has the main four layers with: 

  • Java application layer
  • Database layer
  • Backend API layer
  • Hibernate framework layer

Elements of the Hibernate Architecture

There are several aspects and scope for Hibernate architecture. To learn more about them, you must know about the elements of Hibernate architecture. 

  • SessionFactory: Sessionfactory provides the method to create session objects that are present in the org.hiberate package only. It is thread-safe in nature, immutable, and holds and preserves the second-level cache of the data. 
  • Session: Session objects provide the interface for Connection and Database software via the hibernate framework. 
  • Transaction: Interface that aids transaction management and allows a change in the database. 
  • ConnectiveProvider: A part of the JDBC connections, it separates the main application from the DataSource or DriverManager. 
  • TransactionFactory: Represents the factory of the transaction.

38. What is an exception hierarchy in Java?

The exception defines the unwanted events that present themselves during the run or execution of the program. Exception disrupts the regular flow of the program.
Exception Hierarchy is part of the java.lang.Exception class and comes under the primary Throwable class only. Another subclass ‘Error’ also represents the Throwable class in Java. Though Errors are unusual conditions in case of a failure, still they are not handled or cleared with the Java programs.
There are two primary subclasses for exceptional hierarchy in Java with RuntimeException class and IOCException Class. 

39. What is synchronisation?

Synchronisation in Java defines the capability to manage and control the access of multiple threads to a particular resource. So that, one thread can access a specific resource at the present time. Here, Java allows the development of threads and then synchronising tasks via the synchronising blocks. 

 These Synchronised blocks allow only one thread execution for a particular time and block the other threads until the current thread exits in the block. Here monitors concept is crucial in implementing the synchronisation in Java. Once the thread goes in a lock phase, it is termed to enter the monitor. Thus, locking all the other threads unless the first thread has exited the monitor.

40. What are the features that make Java one of the best programming languages?

Here are the top features that make Java for starting your learning curve in the programming world:

  • Simplicity: Java is quite simple to learn and write. Java syntax is in C++ that allows the developers to write programs seamlessly. 
  • OOPS: Java is based on the object-oriented programming system (OOPS), thus, empowering to build code in multiple types of objects with different data and behaviour.
  • Dynamic: Java is a complete dynamic language that supports the loading of dynamic classes whenever and wherever required. And it also has comprehensive support for native code language such as C, C++, etc.
  • Platform Independent: Java also supports exclusive and platform-independent programming language, thus, allowing developers to run their program on their platform only.
  • Portability: Java has a reach once write anywhere approach that allows the code to run on any platform. 
  • Security: Following the concept of ByteCode, exception handling, and no use of any explicit pointers makes Java a highly secured environment. 

Java is also architect neutral with no dependency on any architecture. Strong memory management and automated garbage collection add more robustness to its environment. 

41. What makes Java enable high performance?

Use of Just in Time (JIT) compiler in its architecture makes Java one of the high performing programming languages, as it transforms instructions into bytecodes.

42. Name most popular Java IDE’s.

There are many IDE’s available in the industry for Java. Here are the top five Java IDEs that you can use to start learning this programming language today: 

  • Eclipse
  • Netbeans
  • IntelliJ
  • JDeveloper
  • MyEclipse

43. Define the main differences between Java and other platforms?

 Two main differences that make Java stand out from other platforms are:

  • Java is primarily a software-based platform, while others can be either software or hardware-based platforms. 
  • Java runs or executes on any hardware platform, whereas others require specific hardware requirements.

44. What makes Java have its ‘write once and run anywhere’ (WORA) nature?

Well, the one-word answer is Bytecode. Java compiler converts all the Java programs into a specific Byte Code acting as a mediator language between the machine code and source code. ByteCode can run on any computer and has no platform dependency. 

45. Explain the different types of access specifiers used in Java.

In the Java programming language, access specifiers represent the exact scope for class, variable, or a method. There are four main access specifiers:

  • Public defined variables, methods, or classes are accessible across any method or class. 
  • Protected access specifier defines the scope of a class, method, and variable to the same package, within the same class, or to that particular subclass of class. 
  • The Default scope is there for all the present classes, variables, and methods with access to the package only. 
  • The Private scope keeps access of class, variables, and methods to a particular class only. 

Read: Java Swing Project

46. Explain the meaning of packages in Java along with their advantages.

Packages are a grouping mechanism for similar types (interface, classes, annotations, and enumerations) ensuring the protection of the assets and comprehensive name management. 

 Here are the advantages of packages in Java:

  • Packages help us prevent naming conflicts when classes of the same name exist in two different packages.
  • Packages aid in making access control systematically. 
  • Build hidden classes to be used by the packages. 
  • Helps in locating related classes for the package.

47. How would you define Constructor in Java?

Constructors are a special block of codes that initialises an object in the time of creation. Though it has a resemblance to instance method, still Constructors are not the method, as they don’t have any explicit return type. So every time an object is being created in the system, there is one constructor called for that to execute. If there is no constructor defined, then the compiler uses a default constructor. 

Here is a simple presentation of Constructor in Java:

1
2
3
4
5
6
public class MyClass{
   //This is the constructor
   MyClass(){
   }
   ..
}

48. What are the different types of constructors used in Java?

There are three types of constructors used in Java: 

  • Default Constructor: When a developer doesn’t use a constructor, Java compiler adds a more specific default constructor existing in the .class file. 
  • No-argument Constructor: In this case, there are no arguments in the constructor and the compiler doesn’t accept any parameter, as instance variable method gets initialised with specific fixed values. 
  • Parameterized Constructor: In this case, one or more parameters are present in the constructor written inside the parentheses of the main element only.

49. What are the differences between constructors and methods?

The main difference in the constructors and methods are: 

  • Purpose: Constructors aim is to initialise the object of a class whereas method performs specific tasks on code execution. 
  • The method has return types while constructors do not.
  • In Methods, there are abstract, static, final, and synchronisation while in constructors, you can’t make specific procedures. 

50. Explain the meaning of Local variable and Instance variable?

  • Local variables are present in the method, and the scope exists within the method only. 
  • Instance variables are present and defined in the class only with their scope across the class. 

51. Explain the meaning of Class in Java?

In Java, all the codes, variables, and methods are defined in the class.  

  • Variables represent attributes that define the state of a particular class.
  • Methods represent where business logic takes its effect. Methods include a set of statements and instructions to match the requirements.

Here is a simple example for a class in Java:

1
2
3
4
5
6
7
public class Addition{ //Class name declaration
int x = 10; //Variable declaration
int y= 10;
public void add(){ //Method declaration
int z = a+b;
}
}

52. Explain the meaning of Object in Java?

Objects are defined as an instance of a class only with specific state and behaviour. For example, a dog with a specific state of name, breed, and colour while behaviour includes barking, wagging the tail, etc. So anytime JVM reads any new() keyword then a corresponding instance will be created. An object needs to be first declared, then instantiated and finally initialised for performing further.  

53. Define the default value for byte datatype in Java language.

For the Byte data type, the default value is 0.  

54. Why is byte data type more beneficial in Java?

As byte data type is almost four times smaller than an integer, so it can store more space for large arrays. 

55. Explain the OOPs concepts in Java.

OOPs, are the fundamental concepts of the Java programming language. These include abstraction, polymorphism, inheritance, and encapsulation. Java OOPs concepts empower developers to create variables, methods, and components that further allow them to reuse them in a customised way while maintaining security. 

56. Explain the meaning of Inheritance.

In Java, Inheritance is a specific mechanism that allows one class to acquire the properties (with fields and methods) of another class. Inheritance is one of the basic concepts of Java OOPs. 

Inheritance makes it possible to build new classes, add more fields and methods on the existing classes for reusing them in any way. 

  • A subclass is the one that inherits the properties of the other class. 
  • Superclass is the one whose properties are inherited. 

57. Explain the concepts of Encapsulation in Java?

As one of the primary concepts of Java OOPs, Encapsulation empowers the wrapping of data and code within a single unit only. Encapsulation is also known as Data hiding, with variables of a specific class hidden from all other classes and accessible with the methods from the existing class only. 

The two essential things for achieving encapsulation in Java are:

  • Declaring the variables of a specific class as a private.
  • Leveraging public setter and getter methods for making changes and viewing the variable values. 

58. Explain the concepts of Polymorphism.

Polymorphism in Java allows developers to perform a single task in multiple ways. There are two types of Polymorphism in Java with Runtime and Compile time. You can use overriding and overloading methods to operate Polymorphism in Java. 

59. Explain the meaning of interface.

In Java, we cannot achieve multiple inheritances. Here, interface plays a crucial role in overcoming this problem to achieve abstraction, aid multiple inheritances, and also supports loose coupling. Now we have a default, static, and private method in interface with the latest Java updates. 

60. What is meant by Abstract class?

Abstract classes are built with a specific abstract keyword in Java. They represent both abstract and non-abstract methods. 

61. Explain the Abstraction Class in Java?

Abstraction is one of the essential properties for hiding the implementation information from the user and then representing the user functions only. For instance, when you send an SMS from one person to another person. The user gets to know only the message and number while the backend process remains hidden.

You can achieve abstraction in Java using the following two ways:

  • Abstract Class (0 to 100%)
  • Interface (100%)

62. Explain the difference between Abstraction and Encapsulation in Java.

Here are the main differences:                       

Abstraction Encapsulation
Abstraction aims to gain information. Encapsulation’s main aim is to contain or procure information.
In the abstraction process, issues or problems are handled at the interface/ design level. In Encapsulation, problems are handled at a specific implementation level.
Abstraction aids in hiding unwanted information. Encapsulation method applies hiding data within a single unit.
Implemented with interfaces and abstract classes. Implemented with a particular access modifier (public, private, and protected).
Use abstract classes and interfaces to hide complexities. Use getters and setters to hide data.
Objects that extend to abstraction must be encapsulated. An object for encapsulation must not be abstracted.

 63. Explain the differences between Abstract class and interface.

Abstract Class Interface
Abstract Class comes with a default constructor. The interface doesn’t have a constructor. So, no further process.
Uses both Abstract and Non-Abstract methods. Only use Abstract methods.
Classes that must extend for Abstract class need only abstract methods throughout their sub-class. Classes that extend to interface must provide implementation across all the methods.
These include instance variables. The interface presents constants only.

64. Explain the main differences between Array and Array List.

Array Array List
The size needs to be defined for the declaring array.

String[] name = new String[5]

No size requirements; and modifies dynamically.

ArrayList name = new ArrayList

You must specify an index for putting an object inside the array.

name[1] = “dog”  

There are no index requirements.

 

name.add(“dog”)

Arrays are not parameterised. From Java 5.0 onwards, ArrayLists have a specific parameterised type.

65. Explain the difference between static method and instance method.

Static or Class Method Instance Method
You must declare a method static for a static method. All methods with declaration as static come under Instance method only.
No requirements for creating objects in the Static method. The object is a must for calling the instance method.
You cannot access Instance or Non-static methods in the static context. You can access both static and non-static in the instance method.

66. How to make Constructors static?

Constructors invoked with the object, and static context is part of the class, not the object. Hence, constructors cannot be static and show compiler error if run or executed. 

67. Explain the use of ‘this’ keyword in Java?

In Java, ‘this’ keyword represents a specific reference on the current object. There are multiple uses for this keyword for referring to the current class properties from a variable, constructors, methods, and more. You can also pass this as an argument within constructors or methods. You can also fetch this as a return value from the current class instance. You can also refer to this as a static context. 

Also Read: How to Code, Compile and Run Java Projects

68. What is a classloader in Java? What are the different types of ClassLoaders in Java?

 Java Classloader’s main function is to dynamically load all classes into the Java Virtual Machine (JVM). ClassLoaders are part of the JRE only. So every time we run a Java program, classloader loads the classes to execute this program. A single ClassLoader loads only a specific class on requirements and uses getClassLoader() method to specify the class. These classes are loaded by calling their names, and in case these are not found then it retrieves or throws a ClassNotFoundException or NoClassDefFoundError. 

 Java ClassLoader uses three principles in performing tasks with delegation, uniqueness, and visibility.
There are three different types of Java ClassLoader: 

  • BootStrap ClassLoader: 

BootStrap ClassLoader represents the parent or superclass for extension classloader and all other classloaders. It has machine code that loads the pure first Java ClassLoader and takes classes from the rt.jar and also known as Primordial ClassLoader. 

  • Extension ClassLoader: 

Extension ClassLoader represents the child classloader for the superclass or BootStrap ClassLoader. It loads core java classes from jre/lib/ext, i.e., JDK extension library. 

  • System ClassLoader: 

Application or System ClassLoader are further child classes of Extension ClassLoader. It takes and loads a file from the current directory for the program that you can customise with the ‘classpath’ switch.

69. Explain the meaning of Java Applet.

Java Applet is a program that executes or runs in the web browser only. Applets are specifically designed to function and embed with HTML web pages. Applets have the capability to function full Java applications with the entire use of Java API. JVM is a must requirement to view an applet on the browser. Applet extends with the use of java.applet.Applet class.

70. What are the types of Applets?

Based on location, there are two types of Java applets as Local Applets that are stored on the same computer or system. The Remote Applets that have files on remote systems.

71 What are immutable objects in Java?

In Java, immutable objects are the ones whose state does not change after it has been created. Immutable objects are ideal for multi-threaded applications that allow sharing the threads while avoiding synchronisation. Immutable objects are preferred for building simple, sound and reliable code to match with an effective strategy. 

72. What do you mean by JRE (Java Runtime Environment)?

Java Runtime Environment is the software layer that provides support for minimum requirements to run Java programs on a machine. Along with JDK and JRE, these three constitute the fundamental for running and developing Java programs on a specific machine. 

73. What is a JDK part of?

Java Development Kit (JDK) is one of the primary technology packages essential for running Java programs. It can be the implementation from any one of the Java platforms, Standard Edition, Micro or Enterprise edition developed by Oracle for building applications on Windows, Linux, or macOS.

74. What is a Java Virtual Machine (JVM)?

Java Virtual Machine (JVM) is one of the three fundamental requirements for running and executing Java programs along with JDK and JRE. JVM has two primary functions; first, to empower Java programs to seamlessly run on any machine or system and second to optimise memory to deliver performance.

75.What are the differences between JDK, JRE, and JVM?

JVM
JRE
JDK
Java Virtual Machine Java Runtime Environment Java Development Kit
Platform dependent with several software and hardware options available. Software layer that provides support for minimum requirements to run Java programs on a machine.

Standard Edition

Enterprise Edition

Micro Edition

 

Three notions as:

  • Specification
  • Implementation
  • Instance
Set of libraries + files that empower JVM on runtime. JRE + development tools
Provides runtime environment for execution. JRE represents the implementation of JVM. Software development environment.

76. How many types of memory areas are there in JVM?

There are several types of memory areas in JVM:

  • Class Area: This memory stores pre-class structures with the field, pool, method data, and code. 
  • Heap stands for runtime memory specifically allocated to the objects. 
  • Stack represents the frame’s memory with a local variable, partial results, thread, and a frame for each method.
  • Program Counter Register stores the information for current instruction with the Java Virtual machine execution. 
  • Native method Stack stores all the present native methods being used in the current applications. 

77. What is Data Binding in Java?

Data binding represents the connections between class and method, field, variable, constructors, or a method body. Java can handle data binding both statically and dynamically.

78. What are the different types of data binding in Java?

There are two crucial types of data binding in Java.

  • Static Binding happens at compile time using static, final, and private methods; also known as early binding. 
  • Dynamic Binding presents at runtime with no exact information known about the right method during the compile time.

79. What is a Java Socket?

Sockets help in building communication mechanisms from the two computers via TCP. Sockets are ideally more sufficient and flexible for communications. 

80. Explain the difference between Path and Classpath.

Both path and Classpath represent local environment variables. The path provides the software to locate the executable files while ClassPath specifies the location for .class files in the system. 

81. Is there an abstract method without the use of abstract class?

No, for an abstract method to exist in a class, it must be an abstract class.  

82. What is the process of making a read-only class in Java?

In Java, you can make a read-only class by keeping all the fields private. This specific read-only class will have only getter methods that return private property. It does not allow to modify or change this property as no setter method is available.

1
2
3
4
5
6
7
8
9
//A Read-only class in Java    
public class Student{    
//private data member    
private String institute ="MKG";    
//getter method for institute
public String getInstitute (){    
return institute;    
}    
}

83. What is the process for making a write-only class in Java?

In Java, you can also make a write-only class by keeping all the fields private with the implementation of setter methods only.

1
2
3
4
5
6
7
8
9
// A write-only class in Java    
public class Student{    
//private data member    
private String institute;    
//setter method for institute
public void setInstitute (String institute){    
this.institute=institute;    
}    
}

84. Explain the way to access a class in another class in Java?

In Java, there are two ways to access a class in another class as:

  • Using the specific name: We can access a particular class from a different package by using the qualified name or import that package that contains a specific class. 
  • Using the relative path: Similarly, we can also use the relative path for that package with a specific class.

85. What is Exception Handling?

Exception handling represents the mechanism to handle the exception or abnormal conditions during the runtime errors to keep the normal flow of the application. There are three different types of Java Exceptions with Checked Exception, Unchecked Exception, and Error. 

86. Explain the difference between Checked Exception and Unchecked Exception.

  • Checked Exceptions are classes that further extend throwable classes except for RuntimeException such as SQLException, IOException, etc. Checked Exceptions are handled during the compile-time only. 
  • Unchecked Exceptions are classes that extend RuntimeException such as NullPointerException, ArithmeticException, etc. and are not handled during the compile time.

 87. Which is the base class for Exception and Error?

Here, the Throwable class represents the base class for Exception and Error.

88. Mention the Exception handling keyword in Java.

There are five keywords for handling exceptions in Java are:

Keyword Description
try This try block defines the block for placing the execution code. This try block is generally followed by the use of either catch or finally. So, they can’t be used alone.
catch Catch block’s main aim is to handle the exception. You must use this in combination with try block and then finally in the later stage.
finally Finally, block checks the important code of the program that checks whether execution is done or not.
throw The main aim of the throw keyword is to throw an exception from the program.
throws The throws keyword is mainly used for declaring exceptions and not for throwing an exception. It provides information about occurrence for exception and is applied with a method signature.

89. Explain the importance of the finally block.

Here, the finally block has crucial importance in the smooth running of the program. It is always executed whether the exception is handled or not. Finally, the block comes after the try or catch block. In the JVM, the system will always run the finally block before terminating or closing a file. For each try block present, there can be zero or multiple catch blocks, still there can only one finally block. 

90. Is running a finally block possible without a catch block?

Yes, a finally block can run followed by either a try or catch block, respectively. 

91. Are there any cases for not existing finally block?

Finally block does not run or execute in case the program already exists or brings fatal error for aborting the process. 

92. Explain the main differences between throw and throws.

throw keyword

throws keyword

It throws an exception. It declares an exception.
Checked exceptions can’t propagate with throw only. Checked exceptions can propagate with throws.
It is followed by an instance. It is followed by a class.
It is used in the method only. It is used with a specific method signature.
There are no possibilities for multiple exceptions. Whereas in this procedure, multiple exceptions can be declared.

93. Is there a possibility for an exception to be rethrown?

Yes, if an exception exists, then it can be rethrown.

94. Explain about Exception Propagation.

The process of exception within the handling procedure is known as exception propagation. For instance, an exception is first handled at the top of the stack and then if it is not caught then the exception drops to the previous method and if not, then it goes down further till either the exception gets caught, or it reaches the bottom of the stack. Checked exceptions by default have no propagation. 

95. Explain the meaning of thread in Java.

In Java, the way or flow of the execution is known as the thread. So, every program contains one thread termed as the main thread created by the JVM. Developers have the power to define their custom threads by adding and extending the Thread class using the interface. 

96. Explain the meaning of the thread pool.

Java thread pool is a group of multiple threads that are continuously waiting for allocated tasks. Here Thread pools work under the service provider that pulls a thread from this pool and then assign them the task for a specific job. The Thread pool adds more performance and stability to the system.

97. Explain the difference between String and StringBuffer.

String

StringBuffer

String class is immutable in nature. StringBuffer class, on the other hand, is mutable.
Strings are slow. StringBuffer otherwise is quite fast.
These consume more memory for creating a new instance. These consume less memory with concat strings.
Strings allow the comparison of its content, as it overrides the equals() method from the Object class. Whereas the StringBuffer class cannot override the equals() method from the Object class.

98. Explain the difference between StringBuffer and StringBuilder.

StringBuffer

StringBuilder

It is synchronised with safety to threads. It is non-synchronised with no safety to threads.
In this, two threads have no call method. In this, two threads can have call methods seamlessly.
Lower or less efficient than StringBuilder. More efficient than StringBuffer.

99. What is the way to create an immutable class in Java?

In Java, you can create an immutable class by declaring a final class with all its members as final. Let’s take an example to understand this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public final class Employee{  
 	final String securityNumber;  
 	  
 	public Employee(String securityNumber){  
 	this.securityNumber=securityNumber;  
 	}  
 	  
 	public String getSecurityNumber(){  
 	return securityNumber;  
  }  
    
  }

99. What are inner classes?

Java Inner classes are defined and declared within an interface or class. Inner classes allow the system to group classes and interfaces logically making them more readable as well as easy to maintain them. Moreover, these classes can access all members of the outer class with methods as well as private data members. 

100. What are the main advantages and disadvantages of using Java Inner classes?

Main advantages for Java inner classes include:

  • Accessibility to all members from the outer classes.
  • Less code to write.
  • More maintenance and readable code.

 The main disadvantages for Java inner classes include:

  • Less support from the IDE. 
  • A high number of total classes. 

101. Define the types of inner classes in the Java programming language?

Inner classes have three main types: 

  • Member Inner class that specifies a class within the class using the outside method.
  • Anonymous Inner Class for extending the class or specifying the implementation of an interface. 
  • Local Inner Class to create a class within the method. 

102. Define a nested class.

Nested classes are defined or declared within a class or interface only. A nested class can specifically access all the members of the outer class with methods and private data members too. Here is a simple syntax of a nested class:

1
2
3
4
5
6
 	class Java_Outer_class{    
 	 //code    
 	 class Java_Nested_class{    
 	  //code    
 	 }    
 	}

103. Can you explain the difference between inner classes and nested classes?

All inner classes are defined as non-static nested classes. So, inner classes are part of the nested classes only.  

104. How would you define the meaning of Collections in Java?

Collections in Java are a group of multiple objects that present as one unit; primarily known as a Collections of the objects. They are also called a Collection Framework or architecture that provides storing space for objects and further manipulates design for changes. 

Here are the main functions performed by the Java Collections:

  • Sorting
  • Searching
  • Insertion 
  • Manipulation 
  • Deletion

There are many interfaces and classes that are part of the collections. 

105. Which interfaces and classes are available in the collections?

Here is the list of the interfaces and classes that are available with the collections in Java. 

  • Interfaces: Collection, Queue, Sorted Set, Sorted Map, List, Set, Map
  • Classes: Lists, Vector, Array List, Linked List
  • Sets: Hash set, Tree set, Linked Hash Set
  • Maps: Hash map, Hash Table, TreeMap, Linked Hashed Map
  • Queue: Priority Queue 

106. Explain sorted and ordered in relation to collections in Java?

  • Sorted: Sorting allows the group of objects to apply internally or externally to sort them in a particular collection, based on their different properties. 
  • Ordered: Defines the values that are sorted on the basis of the values added in the collection and iterate them in a particular order.

107. Which are the different lists available in the collection?

Lists store values based on their index position with the duplication allowed. Here are the main types of lists:
Array Lists: Uses the Random Access Interface, provides order collection by the index, not sorted, and offers quick iteration. Here is an example to understand this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class Fruits{
public static void main (String [ ] args){
ArrayList <String>names=new ArrayList <String>();
names.add (apple);
names.add (avocado);
names.add (cherry);
names.add (kiwi);
names.add (oranges);
names.add (banana);
names.add (kiwi);
System.out.println (names);
}
}

Output is as follows:

[Apple, avocado, cherry, kiwi, oranges, banana, kiwi]

With the output, you can check that Array List keeps the original insertion order and also allows duplicates. Though not sorted. 

Vector: also uses the Random-access method, are synchronised, and offers support for thread safety.

Let us understand this with an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class Fruits{
public static void main (String [ ] args){
ArrayList <String>names=new vector <String>();
names.add (kiwi);
names.add (oranges);
names.add (banana);
names.add (apple);
names.add (avocado);
names.add (cherry);
names.add (kiwi);
System.out.println (names);
}
}

Output is as follows:

[kiwi, oranges, banana, apple, avocado, cherry, kiwi]

Vector lists follow the original insertion order and also support the duplicates.

Linked List: It is also an ideal choice for deletion and insertion, elements are double-linked, but is slow in performance. 

Example for Linked list:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class Fruits{
public static void main (String [ ] args){
ArrayList <String>names=new vector <String>();
names.add (kiwi);
names.add (oranges);
names.add (banana);
names.add (apple);
names.add (avocado);
names.add (cherry);
names.add (kiwi);
System.out.println (names);
}
}

Output is as follows:

[Apple, avocado, cherry, kiwi, oranges, banana, kiwi]

It also follows the original insertion order and accepts duplicates.

108. What are the main differences between collection and collections in Java?

The main differences are as follows:

  • The collection represents an interface while Collections is particularly class only.
  • Collection interface provides multiple functionalities for structuring data as List, Set, and Queue. Whereas Collection class’s main aim is limited to sort and synchronise the elements of the collection. 

109. Explain the Priority Queue.

Priority Queue defines the queue interface for handling linked lists with the purpose of a Priority-in and Priority-out. Queue generally follows a first in first out (FIFO) algorithm, still you can queue elements based on specific requirements, and then we can implement PriorityQueue for customisation. With Priority Queue, it depends on the priority heap either naturally or via the comparator on their relative priority.  

110. When is it ideal to use and compare the Runnable interface in Java?

When we need to extend a class with some other classes and not the threads then runnable interfaces are an ideal choice. 

111. What is the difference between start() and run() method of thread class?

The start() method adds and creates a new thread. And code in run() method gets executed in the new thread only. While run() method will execute code in the current thread only.

112. What is Multithreading?

In Java, we can execute multiple threads simultaneously, which is known as Multithreading. It helps the program to multitask while taking less memory and giving higher performance. In Multithreading, threads are lightweight, share the same space, and are quite affordable in every aspect. 

113. Explain the difference between process and threads.

Here the main differences are:

  • A Java program in execution is termed as a process while a thread represents a subset of the process only. 
  • Processes represent different spaces in the memory, while threads have the same address.
  • Processes are entirely independent, while threads are part of the process only.
  • Slow communication between inter-processes, while the inter-thread communication is swift.   

114. Explain the meaning of inter-thread communication.

Inter-thread communication is defined as the process that allows communication between multiple synchronised threads. Its main aim is to avoid thread pooling in Java. Communication is achieved through the methods of wait(), notify(), and notifyAll(). 

115. Explain the wait() method.

With wait() method, you can allow the thread to be in the waiting stage while the other thread is locked on the object. Thus, the wait() method can add significant waiting duration for threads. 

Here is a syntax to represent this:

1
2
3
4
5
6
public static void main (String[] args){
Thread t = new Thread ();
t.start ();
Synchronized (t) {
Wait();
}

116. What is the main difference between the notify() and notifyAll() method in Java?

notify() method sends a signal to wake up only a particular thread in the waiting pool whereas notifyAll() wakes up all the threads in the waiting stage of the pool. 

117. Define the main differences between sleep() and wait().

Sleep() pauses or stops the current thread progress by suspending execution for a particular duration while not releasing the lock. While wait() causes a waiting duration for a thread after invoking a notify() method for waking later. 

118. Explain the join() method in relation to the thread in Java. 

The join() method allows combining one thread with one of the continuous threads. Here is a syntax for join() method:

1
2
3
4
5
public static void main (String[] args){
Thread t = new Thread ();
t.start ();
t.join ();
}

119. Explain the Yield method of Thread.

Yield method is a static method and does not release any lock in the threads. Here, a Yield() method empowers the current thread to a more runnable thread while allowing the other threads for keeping the execution. Thus, equal thread priority threads can run regularly. 

120. What is the Starvation stage?

Starvation is a phase when a thread fails to gain access to shared resources and is not able to make any progress. 

121. What is Deadlock for a thread?

Deadlock defines a stage when two or multiple threads get blocked forever in wait for each other. 

122. Define Serialisation and Deserialisation in Java?

Serialisation is the process for transforming the state of an object into a particular byte stream ideally suited for JPA, JMS, RMI, JPA, and Hibernate technologies. While the opposite process of changing a byte stream into an object is called deserialisation. Both processes are platform-independent, so they allow you to serialise in one platform and deserialise into an entirely different platform efficiently. 

123. What is the importance of transient variables?

The importance of transient variables lies in the deserialisation that is set to the default variables and not used with the static variables.

124. What are volatile variables?

Volatile variables play a crucial role in the synchronisation and reading from the main memory while avoiding the thread cache memory. 

125. What is SerialVersionUID?

In the Serialised process, an object is stamped with a specific version ID number for the respective object class. This number is termed as SerialVersionUID and plays a crucial role in verifying during the deserialisation process for checking the compatibility on sender and receiver, respectively. 

126. What is the process for cloning an object in Java?

With Object cloning, you can create an exact copy of the original object. For cloning to be possible, a class must have the support for cloning with the java.lang.Cloneable interface and allow override clone() method from the original object class. 

Here a simple syntax for the clone() method:

protected Object clone() throws CloneNotSupportedException

 In case the clone does not implement it then it generally throws an exception with the ‘CloneNotSupportedException’.

127. Define the class that remains superclass for each class?

Object class.

128. Define whether a string class is mutable or immutable?

String class represents an immutable state. So once an object is created, this cannot change any further. 

129. How do you differentiate between StringBuffer and StringBuilder class?

  • StringBuilder is quicker than the StringBuffer. 
  • StringBuffer is synchronised while StringBuilder is not synchronised. 
  • StringBuffer offers a thread-safe environment, while StringBuilder has no thread-safe capability. 

130. What is the use of the toString() method in Java?

In Java, toString() retrieves or returns the string representation from any object. 

131. What is a garbage collection in Java?

As objects get dynamically allocated via the operator, Java system also handles the deallocation of the memory used automatically in case there are no references for the object that remains for a significant duration. This process of keeping the system free of objects that don’t have use is known as Garbage Collection in Java. The main aim of the garbage collection is to make it more memory efficient management. 

132. What is the number of times a garbage collector calls finalize() method for a specific object?

You can call the finalize() method in garbage collection only once. 

133. Define the ways to call the garbage collection.

There are two ways to call the garbage collection:

  • System.gc()
  • Runtime.getRuntime().gc()

134. Can we force Garbage Collection?

No, this is an automatic process. You can call the garbage collection method but can’t force it. Still, it does not guarantee that it would be complete. 

135. What are the different data types in Java? Explain.

Here is a shortlist to help you with data types:

  • byte – 8 bit
  • short – 16 bit
  • char – 16 bit Unicode
  • int – 32 bit (whole number)
  • float – 32 bit (real number)
  • long – 64 bit (Single precision)
  • double – 64 bit (double precision)

136. Define the Unicode.

Unicodes are a way to define international characters in human languages, and Java uses this Unicode structure to symbolise the characters.

137. Define literal.

A literal is a constant value assigned to a particular variable

  // Here 105 is a literal

int num = 105

138. Define the type of casting in Java?

In the case of assigning a value of one data type to another data type, these two may or may not be compatible and require conversion. Java will automatically convert in case of compatible data types. While if the data types are not compatible, then these must be cast for successful conversion. Casting has two basic types: Implicit and Explicit.  

139. Explain the two different types of typecasting?

  • Implicit: Defines the storing of values from smaller data types into larger data types, performed by the compiler only. 
  • Explicit: Defines the storing of values from larger data types into smaller data types that may result in information loss.

Conclusion

The above Java interview questions will provide a good start for preparing for the interview. Practice your coding skills, too, though, and make sure to be thorough in these questions and their related concepts so that when the interviewer fires a Q, you are ready to win the round with your A. Oh, and don’t forget 3 (inconspicuous) breaths when you present yourself before the interviewer.

If you’re interested to learn more about Java, full-stack software development, check out upGrad & IIIT-B’s PG Diploma in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.

All the best! Hope you Crack your Interviews !!

Land on Your Dream Job

UPGRAD AND IIIT-BANGALORE'S PG DIPLOMA IN SOFTWARE DEVELOPMENT
Learn More

Leave a comment

Your email address will not be published. Required fields are marked *

Our Popular Computer Science Course

Accelerate Your Career with upGrad

×
Know More