Top 130+ Java Interview Questions & Answers 2024

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, 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 is take a deep breath and check the questions that are most likely to be asked.

Check out our free courses related to software development.

Embrace the opportunity to showcase your passion for software programming. These carefully curated interview questions encompass core Java concepts, offering a solid foundation to build upon. Whether unraveling the mysteries of threads or delving into fundamental programming paradigms, remember that preparation is vital. Embrace each question as a chance to demonstrate your enthusiasm and potential. With each response, you paint a picture of your capabilities. So, take a moment, absorb these questions, and approach your interview with newfound confidence. Your journey to a fulfilling software programming career begins here.

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.

Learn Software engineering programs online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Here is a compiled list of comprehensive 24 Java Interview Questions with Answers (latest 2022) 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 other application developed in C, C++, etc.

• Method Area: It is a storage area for compiled code of conventional language. 
• Native  Method Libraries: The library consists of various lists of programming languages such as C, C++, or more. 

Java interview questions and answers like such make for a confident start in any interview. Whenever the interviewer asks you any component-related question, always categorise it and give one line description. This helps in creating a positive impression on the recruiter. 

Check Out upGrad Java Bootcamp

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 procedures.

The object-oriented programming language consists of classes of objects that is linked with methods (functions) they are associated with.  

These concepts of object-oriented programming can contain data and code. The procedures are a common feature of objects that are attached to them. This helps in easy access and modification.

Some of the programming languages that consist of OOPs are C, C++, Python,  and Javascript. 

Check Out upGrad Full Stack Development Bootcamp

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

These types of java interview questions for freshers 2024 will stay relevant and will be asked in the coming times. Stay updated with your answers, and always be prepared to handle these fundamental questions, so brush up on the basics before appearing for your interview.

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.

It helps in reusing code. It builds a relationship between two classes that builds a ‘has-a’ and ‘whole/ part’ relationship. It contains a reference to another class and is said to be having ownership of that class. 

These technical-based java interview questions are asked to gauge the depth of your technical knowledge. Make sure not to keep your answers til a bookish definition; rather, mention how the technology is important or useful in the domain.

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

It is the ultimate base class for all non-primitive data types, directly or indirectly. This fundamental class provides essential methods like equals(), hashCode(), and toString(), which are throughout Java’s class hierarchy. Extending the Object, classes inherit a standardized interface, facilitating interoperability and enabling features like polymorphism and object comparison.

This pivotal superclass embodies the core principles of Java’s object-oriented paradigm, forming the cornerstone of the language’s rich class structure. Understanding its role empowers developers to harness the full potential of Java’s inheritance and abstraction mechanisms.

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.

Before appearing for the interview to tackle these types of java interview questions for freshers, you may refer to the below-mentioned table- 

Finally	Finalize
Used for exception handling	Protected method java.lang.object
It is a block.	It is a method.
Can be followed by try-catch/ without it.	Can be explicitly called from an application program.`
It is used to clean up the resources used in the ‘try’ block.	Clean up the activities related to the object before the destruction.

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.

Some of the features of an anonymous class include-

• It is without any name.
• Only one object is created for it.
• It is used to override a method of a class. 
• It can implement only one interface at a time.

Our learners also read: Java free online courses!

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.

These types of java interview questions for freshers 2024 are relevant and will be asked in the coming times.  Some of the features of system class include

1. One of the core classes in Java.
2. It is a final class and does not provide any public constructors.
3. All members and methods in this class are static.
4. This class cannot be inherited to override its methods.
5. Its purpose is to provide access to system resources.

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

Daemon threads provide background support to non-daemon threads, allowing the program to terminate without waiting for them to finish their execution. These threads are useful for tasks like garbage collection or logging, ensuring that essential operations are managed efficiently and enhancing overall performance and responsiveness of Java applications.

Daemon threads in Java, marked by setDaemon(true), are crucial in maintaining a well-organized and responsive application environment. Unlike user threads, daemon threads don’t prevent the program from exiting once the main execution concludes. They gracefully terminate alongside the main thread, handling auxiliary tasks seamlessly.

By understanding and skillfully implementing daemon threads, developers can optimize resource utilization and enhance the overall user experience, making them an indispensable tool in Java multithreaded programming.

If you have more experience, such as ten years, these types of java interview questions for 10 years experience 2024 can be asked. 

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 it 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 the 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.

Time slicing is useful for non-priority scheduling. Every running- thread would be used for a fixed period. It is used for a predefined slice of time.

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.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

12. Garbage collector thread is what kind of a thread?
It is a daemon thread. It is a low priority thread running in the background.  Operating with lower priority, it discreetly works in the background, automatically managing memory by identifying and reclaiming unused objects. This integral part of Java’s memory management system ensures optimal resource utilization by freeing up memory occupied by objects that are no longer accessible.

The daemon nature of the garbage collector thread allows it to coexist harmoniously with other threads, executing its crucial role without delaying or obstructing the program’s primary functionality. This non-obtrusive yet essential thread contributes to Java’s efficiency and robustness, facilitating smoother application execution.

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.

The volatile variable is casted with a keyword “volatile” to signify that this variable can be changed by some outside factor. 

Some of the key features of the volatile memory-

• It is a field modifier.
• Improves thread performance
• The thread cannot be blocked for being volatile in case waiting. 
• Not subject to compiler optimisation.

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.

Some of the key features of wrapper classes in Java-

• Convert primitive into object and object into primitive.
• Contains the feature of autoboxing and unboxing to transform the primitive into objects and vice verca.

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

Some of the other ways of creating singleton class include-

• Only one instance of class is present. 
• Declare all constructors to be private.
• Provide a static method that runs a reference to instance.

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.

The thread class make performing operations on a thread easier by providing constructors and methods to create. It also facilitates in extending objects class and  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.

There are no default values assigned to the local variables. They should be declared and the initial value should be assigned  before the first use.

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.

Some of the features of Singleton in Java include-

• A singleton class can have only one object or instance of a class at a time. 
• Ensures existence of only class in JVM.
• Must provide global access point to get the instance of  class. 
• It is used for caching, logging, drivers object, thread pool, etc. 

Java interview questions 2024 can be frequently asked in coming times. So do not restrict yourself to one line response, rather mention of few features as well.

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. A static methods are accessed by their class name, rather than object of class.

One significant trait of static methods is their ability to access and modify static data members, promoting efficient data handling. It differentiates them from instance methods that operate within an object’s scope. Utilizing static methods enhances code organization and fosters a modular approach, simplifying the design and maintenance of Java programs by enabling direct class-level interaction.

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.

This exception event occurs at an execution of a program disrupting the normal flow of the program’s instructions. There are various types of exceptions in Java such as-

1. Checked exception
2. Unchecked exception 

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.

Read: Must Read Top 58 Coding Interview Questions & Answers

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:

 	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:

   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

Experienced professionals are expected to have an organised answer for these types of questions. You may choose to tackle java interview questions for 8 years experience 2024 in this manner.

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:

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:

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. 

This unwanted or unexpected event can occur at several times such as compile-time or run- time in an application.

39. What is synchronization?

Synchronization 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 synchronizing tasks via the synchronizing blocks. 

 These Synchronized 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 synchronization 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.

Synchronization gives the capability to control multiple threads at any resource that is shared. Synchronization becomes usefu for reliable communication between threads as the multiple threads might try to access the shared resources at the same time thus producing results that are inconsistent.

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 behavior.
• 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.

The JIT compiler is helpful in compiling of code on demand. The fast and time efficient features come into play because whichever method is called, only that method block gets compiled.

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.

You may refer to the below mentioned table to understand the differences between Java and other platforms-

Java	Other platforms
Software-only platform that runs on top of hardware- based platforms.	Other platforms are usually hardware software or hardware only platforms.
Java code can be developed n any OS.	Other platforms do not have this feature.
Java has its own run time environment such as JRE(Java Run-Time Environment) and JVM (Java Virtual Machine)	This function is missing on other platforms.

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. 

The access modifiers are mainly used for encapsulation. It helps to control what part of program can access the members of a class to prevent the data misuse. 

While tackling questions like such make sure to also make a slight mention of importance of  access modifiers. It gives an edge during java interview questions and answers for freshers.

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. 

The packages are used to categorise the classes and interfaces. The categorisation is done for smoother maintenance. The packages are also useful for providing protection. 

 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.
• Provides access protection. 
• Reuse classes
• Provide controlled access
• Implement data encapsulation
• Easy search

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:

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 initialize 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 synchronization while in constructors, you can’t make specific procedures.

• You may refer to the below mentioned table for differences-

  Constructors	Methods
  It is used to create and initialise the object.	It is used to execute statements.
  Invoked implicitly by the system.	Invoked during the program code.
  Gets executed only when object is created.	Can be executed on beng explicitly called.
  Name is same as the class name.	Name will not be same as the class name.
  Should not have return type.	Should have return type.

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:

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 behavior. For example, a dog with a specific state of name, breed, and colour while behavior 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 initialized for performing further. Each object has its own identity, behavior and state.  The state is stored in fields (variables), methods (functions) showcase the objects behavior. 

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. 

They can also be used in place of int, where their limits help to clarify the code.

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. 

• Abstraction- This is useful for hiding internal details. It is also useful to show functionality.
• Polymorphism- It is when an object behaves differently in different situations. There are two types of polymorphism run-time and compile-time polymorphism.
• Inheritance- It is when an object acquires the properties and behaviours of another object. The object whose quality gets inherited is called a superclass. The object inheriting the properties is called a sub-class. 
• Encapsulation- It is used for binding/ wrapping a code and data together in a unit. Access modifier keywords are also used in this process. 

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.
• Some of the properties of inheritance include-
• Allows to create of a new class from the existing class.
• The object acquires all the properties of the object it is inheriting from.
• The methods can be reused of the superclass.
• New methods and fields can be added to the current class. 
• Inheritance in java can be used for method overriding. 

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.
• Some of the other properties of encapsulation include-
• The code and data(variables) acting upon methods are integrated into a single unit. 
• Other classes cannot access the variables that have been encapsulated. 
• Only the methods of the class can access.

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. 

Some of the properties of polymorphism include- 

• There are different types of polymorphism, such as Static and Dynamic. 
• Polymorphism allows having various forms of objects, variables and methods. 
• The behavior is dependent on the type of data that has been used in operation. 

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. 

Benefits of interface-

• Specify the behaviour an object must implement.
• It acts as a contract between an object and its code.
• They help in making implementation changes easier.
• They act as connecting points between modules.

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. 

Benefits of abstract classes-

• Helps in reducing the complexity of viewing the things.
• Increases the security of an application.
• Avoids code duplication.
• It increases the code reusability.
• It has the ability to independently change the internal implementation of the class without affecting the user badly.

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.
Status methods are used to perform a single operation.	Instance methods are used to perform repetitive operations.
The static must be accessed with a repetitive class name.	The instance method must be accessed with a repetitive object name.
They are alternatively called Class Level Data Members.	They are alternatively called Object Level Data Members.

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

Some of the uses of this keyword include-

• Can be used to invoke the current class constructor.
• Can be used as an argument in the method call.
• Can be used to refer current class instance variable.
• Can be used to invoke the current class method implicitly.
• Can be used to return current class instance from method.

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 synchronization. Immutable objects are preferred for building simple, sound and reliable code to match with an effective strategy. 

Some of the benefits of immutable objects in Java include-

• Safety of threads
• Prevention of identity mutation.
• Brings ease of caching
• Supports referential transparency
• Protection from the corruption of existing objects

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. 

Java Runtime Environment importance-

• Communicates between Java program and the operating system.
• Acts as a translator and facilitator.
• Has the ability to run on any operating system without modifications.
• It provides an environment for Java programs to be executed.

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.

Java Virtual Machine features-

• Code compatability.
• The application can be run anywhere, as it supports (Write Once Run Anywhere).
• Garabage Collection
• Compile Control
• Supports Native Memory Tracking
• Facilitates Class Data Sharing 
• Helps in Signal Chaining

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.

• It binds the data to one object or more to ensure synchronisation. 
• Allows to effortlessly communicate across views and data sources.
• Handles binding either statically or 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.

Refer to the below table for static and dynamic binding difference-

Static Binding	Dynamic Binding
Occurs at Compile Time	Occurs at Runtime
High speed	Low speed
Known as early binding	Known as late binding
Not use of actual object	Use of actual object
Can take place using normal functions.	Can take place using virtual functions.

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. 

Features of Java Socket-

• A java socket point facilitates two-way communication link between two points.
• It is bound to a port number for the TCP layer to identify the application.
• Establish a connection between a client and a server. 

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. 

Refer to the below mentioned table to undesratnd the differences between these two-

Path	Classpath
Environment variable is used by the operating system to find the executable files.	Environment variable is used by rhe Java Compiler to find the path classes.
It is used by CMD prompt in order to find files that are binary.	It is used by compiler and JVMto find files that are binary.
We must place .\bin folder path	We must place .\lib\jar file or directory path

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.

//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.

// 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. 

Exception handling features-

• It is a process of responding to unwanted or unexpected events that happens when a computer program runs.
• Helps to avoid system crashing by handling with events.
• It is a mechanism that allows Java programs to tackle various situations.
• There are various ways an exception can be handled such as-
• Throwing an exception
• Catching an exception
• Handling an exception

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.

Refer to the below mentioned table to understand the difference-

Checked Exception	Unchecked Exception
Also known as compile time exceptions	Also known as Runtime exceptions
Propogated  using throws keywords	Automatically propagated
Occurs when the chances of failure are too high.	Occurs due to programming misfunctionality.
Not sub class of run time exception.	Sub class of run time exception.

 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. 

Some of the other importance of finally block include-

• Used to execute important code such as a closing file, etc.
• Always executed regardless of exception handling.
• Must be the last block of execution in the program.
• Used for resource de-allocation.
• Used to put important codes such as clean-up code

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. 

Features of exception propagation-

• Occurs when an exception is thrown from the top of the stack.
• In case of not being caught, the exception chooses to drop down the call stack of the preceding method.
• In case of not being caught even then, it gets dropped even more.

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. 

Benefits of thread in java-

• Allows the program to operate more efficiently.
• Can be used to perform complicated tasks without interrupting the other programs.
• Can be utilised to free up the main thread.
• Helps to breakup the tasks into smaller units that can be executed simultaneously.

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:

 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. 

Benefits of inner classes-

• They are used to develop readable code.
• Provides easy access
• Having separate classes can be avoided.
• All the members can be accessed, including private members.
• Requires less code to write.

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:

 	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.  

You may refer to the below mentioned table to understand the difference-

Inner class	Nested class
Always associated with the outer class object.	Not associated with the outer class object.
Do not declare static members.	Static members can be declared.
Normally main() method cannot be declared.	The Main() method can be declared.
Static and Non Static members of the outer class can be directly accessed.	Static members of the outer class can be directly accessed.

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:

 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:

 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:

 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.  

Features of priority queues in java include-

• Juggle multiple programs and their execution
• Important to networking systems
• Typically implemented using the heap data structure.

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. 

Features of multi threading in java-

• Allows to create lightweight process
• Multiple threads can be executed can be created in the program.
• Saves time as it helps in running multiple operations.
• The threads are independent, so it does not block other operations.

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. 

Refer to the below-mentioned table to understand the difference-

Process	Threads
Allocate new resources each time a program is run.	Share resources of process.
Generally slower than thread.	Generally faster process.
Communicate through IPC.	Communicate freely.
Have a separate address space.	Share address space.

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:

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. 

Refer to the below-mentioned table between sleep() and wait().

sleep()	wait()
Static method	Non-static method
Doesn’t release lock	Releases the lock
Used to introduce a pause on execution	Used for inter-thread communication

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

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. 

• It is when the thread is not able to gain regular access to the shared resources.
• When shared resources are made unavailable for long periods.

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.

140. Why is Java considered platform-independent?

Java is considered platform-independent due to its use of the Java Virtual Machine (JVM), which allows Java programs to run on any operating system without modification. When a Java program is compiled, it is converted into bytecode, which is a standardized, platform-neutral format. This bytecode is then executed by the JVM, which interprets it for the specific operating system on which it is running. This unique architecture enables the Java philosophy of “write once, run anywhere,” allowing developers to write applications that can be deployed across different systems without needing to be recompiled for each one.

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 Executive PG Programme in Software Development – Specialisation in Full Stack 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 !!