186 Java Interview Questions You Need to Know in 2024

Lesson 29 of 43By Pulkit Jain

Last updated on Sep 24, 2024172263993

180+ Core Java Interview Questions and Answers for 2024
PreviousNext
Table of Contents
Most Asked Java Coding Interview QuestionsJava Basic Interview Questions for
FreshersJava Coding Interview Questions For IntermediateRelated Software Developer
Interview GuidesCore Java Interview Questions for ExperiencedView More
Reviewed and fact-checked by Sayantoni Das
For individuals aiming to excel in the field of software development, understanding
Core Java is fundamental. Whether you're preparing for an interview or looking to
strengthen your Java programming skills, a structured Java Course can significantly
enhance your proficiency.

Java is the most widely used programming language in the current IT industry. One
major reason for the vast number of beginners and professionals in the field of
programming is the career potential that Java knowledge comes with. This article is
dedicated to the same purpose. Here is a complete guide on how to help you crack
the most frequently asked Core Java Interview questions.

Become a Full Stack Developer in Just 6 Months!

Full Stack Java DeveloperExplore ProgramBecome a Full Stack Developer in Just 6
Months!
Most Asked Java Coding Interview Questions
Here are some of the most asked Java interview questions.

What is Java?
Why is Java a platform independent language?
What are the differences between C++ and Java?
Why is Java not a pure object oriented language?
List the features of the Java Programming language?
What do you get in the Java download file?
Explain JVM, JRE, and JDK.
What is a ClassLoader?
What are the Memory Allocations available in JavaJava?
What are the differences between Heap and Stack Memory in Java?
Now, let's discuss the key Java interview questions for freshers and their answers.

Java Basic Interview Questions for Freshers

So let’s get started with the first set of basic core Java technical interview
questions which is primarly useful for freshers.

1. What are the differences between C++ and Java?

Concept.
C++ is not platform-independent; the principle behind C++ programming is “write
once, compile anywhere.”

In contrast, because the byte code generated by the Java compiler is platform-
independent, it can run on any machine, Java programs are written once and run
everywhere.

Also Read: Learn C++ Programming

Languages Compatibility.
C++ is a programming language that is based on the C programming language. Most
other high-level languages are compatible with C++.
Most of the languages of Java are incompatible. Java is comparable to those of C
and C++.

Interaction with the library.

It can access the native system libraries directly in C++. As a result, it’s better
for programming at the system level.

Java’s native libraries do not provide direct call support. You can use Java Native
Interface or access the libraries.

Characteristics.
C++ distinguishes itself by having features that are similar to procedural and
object-oriented languages. The characteristic that sets Java apart is automatic
garbage collection. Java doesn’t support destructors at the moment.

The semantics of the type.

Primitive and object types in C++ have the same kind of semantics. The primitive
and object and classes of Java, on the other hand, are not consistent.

In the context of Compiler and Interpreter.

Java refers to a compiled and interpreted language. In contrast, C++ is only a
compiled language.

In Java, the source code is the compiled output is a platform-independent byte

code.

In C++, the source program is compiled into an object code that is further executed
to produce an output.

2. List the features of the Java Programming language?

A few of the significant features of Java Programming Language are:

Easy: Java is a language that is considered easy to learn. One fundamental concept
of OOP Java has a catch to understand.

Secured Feature: Java has a secured feature that helps develop a virus-free and
tamper-free system for the users.

OOP: OOP stands for Object-Oriented Programming language. OOP signifies that, in
Java, everything is considered an object.

Independent Platform: Java is not compiled into a platform-specific machine;

instead, it is compiled into platform-independent bytecode. This code is
interpreted by the Virtual Machine on which the platform runs.

Dive Deep Into Java Core Concepts

Java Certification TrainingENROLL NOWDive Deep Into Java Core Concepts
3. What do you get in the Java download file? How do they differ from one another?
We get two major things along with the Java Download file.

JDK - Java Development Kit

JRE - Java Runtime Environment

JDK
JRE
Abbreviation for JavaDevelopment Kit

Abbreviation for Java Runtime Environment

JDK is a dedicated kit for solely software development

JRE is a set of software and library designed for executing Java Programs

Unlike JVM, JDK is Platform Dependent

Unlike JVM, JRE is also Platform Dependent

JDK package is a set of tools for debugging and Developing

JRE Package is one that only supports files and libraries for a runtime environment

JDK package will be provided with an installer file

JRE Package does not get an installer but has only a runtime environment

4. What is a ClassLoader?
A classloader in Java is a subsystem of Java Virtual Machine, dedicated to loading
class files when a program is executed; Class Loader is the first to load the
executable file.

Java has Bootstrap, Extension, and Application classloaders.

Also Read: What is Bootstrap and How to Embed Bootstrap into Angular?

5. What are the Memory Allocations available in JavaJava?

Java has five significant types of memory allocations.

Class Memory
Heap Memory
Stack Memory
Program Counter-Memory
Native Method Stack Memory
6. What are the differences between Heap and Stack Memory in Java?
Stack memory in data structures is the amount of memory allocated to each
individual programme. It is a fixed memory space. Heap memory, in contrast, is the
portion that was not assigned to the Java code but will be available for use by the
Java code when it is required, which is generally during the program's runtime.

7. Will the program run if we write static public void main?

Yes, the program will successfully execute if written so. Because, in Java, there
is no specific rule for the order of specifiers

8. What is the default value stored in Local Variables?

Neither the Local Variables nor any primitives and Object references have any
default value stored in them.

9. Explain the expected output of the following code segment?

public class Simplilearn
{
public static void main (String args[])
{
System.out.println(100 + 100 +“Simplilearn");
System.out.println(“E-Learning Company" + 100 + 100);
}
}

The answers for the two print statements are as follows.

200Simplilearn
E-Learning Company100100
10. What is an Association?
An Association can be defined as a relationship that has no ownership over another.
For example, a person can be associated with multiple banks, and a bank can be
related to various people, but no one can own the other.

Get access and complete hands-on experience on a plethora of software development

skills in our unique Job Guarantee bootcamp. Get job-ready by enrolling in our
comprehensive Full Stack Java Developer Masters program today!
11. What do you mean by aggregation?
The term aggregation refers to the relationship between two classes best described
as a “whole/part” and “has-a” relationship. This kind is the most specialized
version of an association relationship. It contains the reference to another class
and is said to have ownership of that class.

12. Define Copy Constructor in Java

A Copy Constructor in Java is a constructor that initializes an object through
another object of the same class.

13. What is a Marker Interface?

An empty interface in Java is referred to as a Marker interface. Serializable and
Cloneable are some famous examples of Marker Interface.

14. What is Object Cloning?

An ability to recreate an object entirely similar to an existing object is known as
Object Cloning in Java. Java provides a clone() method to clone a current object
offering the same functionality as the original object.

15. Can Java be said to be the complete object-oriented programming language

No, Java cannot be treated as a complete object-oriented programming language.

16. What is an object-oriented paradigm?

A Paradigm that is based on the concepts of “Objects.” It contains data and code.
Data that is in the form of fields, and regulation, that is in the form of
procedures. The exciting feature of this paradigm is that the object’s procedures
can access and often modify the data fields themselves.

17. Define Wrapper Classes in Java.

In Java, when you declare primitive datatypes, then Wrapper classes are responsible
for converting them into objects(Reference types).

18. What is a singleton class in Java? And How to implement a singleton class?
A class that can possess only one object at a time is called a singleton class. To
implement a singleton class given steps are to be followed:

Make sure that the class has only one object

Give global access to that object
19. Define package in Java.
The package is a collective bundle of classes and interfaces and the necessary
libraries and JAR files. The use of packages helps in code reusability.

20. Can you implement pointers in a Java Program?

Java Virtual Machine takes care of memory management implicitly. Java's primary
motto was to keep programming simple. So, accessing memory directly through
pointers is not a recommended action. Hence, pointers are eliminated in Java.

Recommended Read: The Complete Reference to Java Programming

21. Differentiate between instance and local variables.
For instance, variables are declared inside a class, and the scope of variables in
javascript is limited to only a specific object.

A local variable can be anywhere inside a method or a specific block of code. Also,
the scope is limited to the code segment where the variable is declared.

22. Explain Java String Pool.

A collection of strings in Java's Heap memory is referred to as Java String Pool.
In case you try to create a new string object, JVM first checks for the presence of
the object in the pool. If available, the same object reference is shared with the
variable, else a new object is created.

23. What is an Exception?

An Exception handling in Java is considered an unexpected event that can disrupt
the program's normal flow. These events can be fixed through the process of
Exception Handling.

24. What is the final keyword in Java?

The term final is a predefined word in Java that is used while declaring values to
variables. When a value is declared using the final keyword, then the variable's
value remains constant throughout the program's execution.

25. What happens when the main() isn't declared as static?

When the main method is not declared as static, then the program may be compiled
correctly but ends up with a severe ambiguity and throws a run time error that
reads "NoSuchMethodError."

Master Core Java 8 Concepts, Java Servlet & More!

Java Certification TrainingENROLL NOWMaster Core Java 8 Concepts, Java Servlet &
More!
26. Why is Java a platform independent language?
One of the most well-known and widely used programming languages is Java. It is a
programming language that is independent of platforms. Java doesn't demand that the
complete programme be rewritten for every possible platform. The Java Virtual
Machine and Java Bytecode are used to support platform independence. Any JVM
operating system can run this platform-neutral byte code. The application is run
after JVM translates the byte code into machine code. Because Java programmes can
operate on numerous systems without having to be individually rewritten for each
platform, the language is referred to as "Write Once, Run Anywhere" (WORA).

27. Why is the main method static in Java?

Java's main() function is static by default, allowing the compiler to call it
either before or after creating a class object. The main () function is where the
compiler begins programme execution in every Java programme. Thus, the main ()
method needs to be called by the compiler. If the main () method is permitted to be
non-static, the JVM must instantiate its class when calling the function.

28. What part of memory - Stack or Heap - is cleaned in the garbage collection
process?
On Heap memory, garbage collection is employed to release the memory used by
objects with no references. Every object created in the Heap space has access to
the entire application and may be referred to from anywhere.

29. What is the difference between the program and the process?
A programme is a non-active entity that includes the collection of codes necessary
to carry out a specific operation. When a programme is run, an active instance of
the programme called a process is launched. A process is begun by a programme once
it has been run. The process carries out the program's specified instructions.
30. What are the differences between constructor and method of a class in Java?
Initializing the state of the object is done by constructors. A function Object ()
{ [native code] }, like methods, contains a group of statements (or instructions)
that are carried out when an object is created. A method is a group of statements
that work together to complete a certain task and return the outcome to the caller.
A method has the option of working without returning anything.

31. Which among String or String Buffer should be preferred when there are a lot of
updates required to be done in the data?
Because StringBuilder is quicker than StringBuffer, it is advised to utilize it
wherever possible. However, StringBuffer objects are the best choice if thread
safety is required.

32. What happens if the static modifier is not included in the main method
signature in Java?
The main function is called by the JVM even before the objects are created, thus
even if the code correctly compiles, there will still be an error at runtime.

33. Can we make the main() thread a daemon thread?

This technique designates whether the active thread is a user thread or a daemon
thread. For instance, tU.setDaemon(true) would convert a user thread named tU into
a daemon thread. On the other side, executing tD.setDaemon(false) would convert a
Daemon thread, tD, into a user thread.

34. What happens if there are multiple main methods inside one class in Java?
There is no limit to the number of major approaches you can use. Overloading is the
ability to have main methods with different signatures than main (String []), and
the JVM will disregard those main methods.

35. How does an exception propagate in the code?

In the event that an exception is not caught, it is initially thrown from the top
of the stack and then moves down the call stack to the preceding method. The
runtime system looks for a way to handle an exception that a method throws. The
ordered list of methods that were called to get to the method where the error
occurred is the collection of potential "somethings" that can be used to manage the
exception. The call stack is the list of methods, and exception propagation is the
search technique.

36. How do exceptions affect the program if it doesn't handle them?

If you don't deal with an exception once it occurs, the programme will end abruptly
and the code after the line where the exception occurred won't run.

37. Is it mandatory for a catch block to be followed after a try block?

Each attempt block does not necessarily have to be followed by a catch block.
Either a catch block or a final block ought to come after it. Additionally, any
exceptions that are expected to be thrown should be mentioned in the method's
throws clause.

38. Can you call a constructor of a class inside another constructor?

Yes, a class may include any number of constructors, and each function Object ()
{[native code] } may call the others using the this() function Object() { [native
code] } call function [please do not mix the this() function Object() { [native
code] } call function with this keyword]. The constructor's first line should be
either this () or this(args). Overloading of constructors is what this is called.

Dive Deep Into Java Core Concepts

Java Certification TrainingENROLL NOWDive Deep Into Java Core Concepts
39. Contiguous memory locations are usually used for storing actual values in an
array but not in ArrayList. Explain.
Primitive data types like int, float, and others are typically present in an array.
In such circumstances, the array immediately saves these elements at contiguous
memory regions. While an ArrayList does not contain primitive data types. Instead
of the actual object, an ArrayList includes the references to the objects' many
locations in memory. The objects are not kept in consecutive memory regions because
of this.

40. Why does the java array index start with 0?

The distance from the array's beginning is just an offset. There is no distance
because the first element is at the beginning of the array. Consequently, the
offset is 0.

41. Why is the remove method faster in the linked list than in an array?
Because there is no background scaling of an array, insertion, addition, and
removal operations are quicker with a LinkedList. Only references in adjacent items
need to update when a new item is added in the middle of the list.

42. How many overloaded add() and addAll() methods are available in the List
interface? Describe the need and uses.
List is an interface in the Java Collections Framework. The add() and addAll()
methods are the main methods at the List interface. The add() method is used
to add an element to the list, while the addAll() method is used to add a
collection of elements to the list.
The List interface contains two overloaded versions of the add() method: The
first add() method accepts a single argument of type E, the element to be added to
the list.
The second add() method accepts a variable number of arguments of type E, which are
the elements to be added to the list.

The List interface also contains two overloaded versions of the addAll() method:

The first addAll() method accepts a single argument of type Collection<? Extends
E>, which is the collection of elements to be added to the list.

The second addAll() method accepts a variable number of arguments of type E, which
are the elements to be added to the list.

43. How does the size of ArrayList grow dynamically? And also state how it is
implemented internally?
A resizable array implementation in Java is called ArrayList. Dynamically expanding
array lists make it possible to add new elements at any time. The underlying data
structure of the ArrayList is an array of the Object class. The ArrayList class in
Java has three constructors. There are available readObject and writeObject methods
specific to it. The Object Array in an ArrayList is temporary. There are
implemented and Serialization-capable versions of RandomAccess, Cloneable, and
java.io (that are Marker Interface in Java).

44. Although inheritance is a popular OOPs concept, it is less advantageous than

composition. Explain.
A class's testability is improved through composition over inheritance. If a class
is comprised of another class, it is simple to create a mock object to simulate the
combined class for testing purposes. This privilege is not given by inheritance.
Even while Composition and Inheritance both let you reuse code, Inheritance has the
drawback of breaking encapsulation. If the function of the subclass depends on the
superclass's action, it suddenly becomes vulnerable. Sub-class functionality may be
broken without any alteration on the part of the super-class when its behaviour
changes.
45. What are Composition and Aggregation? State the difference.
Aggregation (HAS-A) and composition are its two forms (Belongs-to). In contrast to
composition, which has a significant correlation, the aggregation has a very modest
association. Aggregation can be thought of as a more confined version of the
composition. Since all compositions are aggregates but not all aggregates are
compositions, aggregate can be thought of as the superset of composition.

Master Java programming and elevate your career with the Java Certification Course
by Simplilearn. Gain in-demand skills and become job-ready. Enroll now and
transform your future!
46. How is the creation of a String using new() different from that of a literal?
The new () operator always produces a new object in heap memory when creating a
String object. The String pool may return an existing object if we build an object
using the String literal syntax, such as "Baeldung," on the other hand.

47. How is the ‘new' operator different from the ‘newInstance()' operator in java?
Both the new operator and the newInstance() method are used to create objects in
Java. If we already know the kind of object to create, we can use the new operator;
however, if the type of object to create is supplied to us at runtime, we must use
the newInstance() function.

48. Is exceeding the memory limit possible in a program despite having a garbage
collector?
Yes, even with a garbage collector in place, the programme could still run out of
memory. Garbage collection aids in identifying and removing programme objects that
are no longer needed in order to release the resources they use. When an object in
a programme cannot be reached, trash collection is executed with respect to that
object. If there is not enough memory available to create new objects, a garbage
collector is used to free up memory for things that have been removed from the
scope. When the amount of memory released is insufficient for the creation of new
objects, the program's memory limit is exceeded.

49. Why is synchronization necessary? Explain with the help of a relevant example.
Multiple threads trying to access the same resources in a multi-threaded software
may frequently result in unexpected and incorrect outcomes. Therefore, it must be
ensured through some form of synchronization that only one thread can access the
resource at any given time. Java offers a method for setting up threads and
synchronizing their operations with the aid of synchronized blocks. The
synchronized keyword in Java is used to identify synchronized blocks. In Java, a
synchronized block is one that is tied to an object. Only one thread can be running
at a time inside synchronized blocks since they are all synchronized on the same
object. Until the thread inside the synchronized block exits the block, all other
threads trying to enter the block are blocked.

50. Define System.out.println().

System.out.println() in Java outputs the argument that was supplied to it. On the
monitor, the println() method displays the findings. An objectname is typically
used to call a method.

51. Can you explain the Java thread lifecycle?

A thread can be in any of the following states in Java. These are the states:

New: A new thread is always in the new state when it is first formed. The function
hasn't been run yet, thus it hasn't started to execute for a thread in the new
state.
Active: A thread switches from the new state to the active state when it calls the
start() method. The runnable state and the running state are both contained within
the active state.
Blocked or Waiting: A thread is either in the blocked state or the waiting state
when it is inactive for a while (but not indefinitely).
Timed waiting: When we use the sleep () method on a particular thread, we are
actually engaging in timed waiting. The thread enters the timed wait state using
the sleep () function. The thread awakens when the allotted time has passed and
resumes execution where it left off.
Termination: A thread that has been terminated means it is no longer active in the
system. In other words, the thread is inactive and cannot be revived (made active
again after being killed).
52. What could be the tradeoff between the usage of an unordered array versus the
usage of an ordered array?
When opposed to an unordered array, which has a time complexity of O, an ordered
array's search times have a time complexity of O(log n) (n). Due to the need to
shift the elements with higher values to create room for the new member, an ordered
array has a temporal complexity of O(n) during the insertion process. Instead, an
unordered array's insertion operation requires a constant O amount of time (1).

53. Is it possible to import the same class or package twice in Java and what
happens to it during runtime?
The same package or class may be imported more than once. Neither the JVM nor the
compiler raise an objection. Even if you import the same class several times, the
JVM will only internally load it once.

54. In case a package has sub packages, will it suffice to import only the main
package? e.g. Does importing of com.myMainPackage.* also import
com.myMainPackage.mySubPackage.*?
Sub-packages won't be imported when a package is imported. When you import a
package, all of its classes and interfaces—with the exception of those from its
sub-packages—are imported.

55. Will the final block be executed if the code System.exit(0) is written at the
end of the try block?
The system is established as the last line to be run, after which nothing will
happen, therefore both the catch and finally blocks are essentially ignored.

56. Explain the term “Double Brace Initialisation” in Java?

The outer braces of the double-brace initialization construct an anonymous class
that is descended from the provided class and gives an initializer block for that
class (the inner braces).

57. Why is it said that the length() method of String class doesn't return accurate
results?
Since this char [] array is used by the Java String class internally, the length
variable cannot be made public.

58. What are the possible ways of making objects eligible for garbage collection
(GC) in Java?
If a reference variable for an object is removed from the programme while it is
running, the object may be trash collected. They are also referred to as
inaccessible objects occasionally. The new operator returns a reference to an
object after dynamically allocating memory for it.

59. In the below Java Program, how many objects are eligible for garbage
collection?
I don't know about the program, but generally, three objects are eligible for
garbage collection.

The first object is created when the program is started and is no longer needed
when the program ends.
The second object is created when the user inputs their name and is no longer
required when the program ends.

The third object is created when the user inputs their address and is no longer
needed when the program ends.

60. What is the best way to inject dependency? Also, state the reason.
Constructor injection. A class requesting its dependencies through its function
Object() { [native code] } is the most typical instance of dependency injection.
Since the client cannot be constructed without the required dependencies, this
guarantees that it is always in a correct state.

Get Mentored by Leading Java Experts!

Full Stack Java DeveloperExplore ProgramGet Mentored by Leading Java Experts!
61. How we can set the spring bean scope. And what supported scopes does it have?
There are four ways to set the scope of a Spring bean: singleton, prototype,
request, and session.

The singleton scope creates a single instance of a bean, which is shared by all
objects that request it.

The prototype scope creates a new instance of a bean for each object that requests
it.

The request and session scopes are only available in a web-based context. The
request scope creates a new bean instance for each HTTP request, and the session
scope creates a single instance of a bean shared by all objects in a single HTTP
session.

62. What are the different categories of Java Design patterns?

The three categories of Java design patterns are creational, structural, and
behavioural design patterns.

63. What is a Memory Leak? Discuss some common causes of it.

A memory leak is the slow degradation of system performance over time brought on by
the fragmentation of a computer's RAM as a result of shoddy application design or
programming that fails to release memory chunks when they are no longer required.
These memory leaks frequently result from session items in excess, insertion into
Collection objects without deletion, infinite caches, excessive page switching on
the operating system, listener methods that are not called, and bespoke data
structures that are poorly written.

64. Assume a thread has a lock on it, calling the sleep() method on that thread
will release the lock?
No, the thread might release the locks using notify, notifyAll(), and wait()
methods.

65. Write a Java Program to print Fibonacci Series using Recursion.

class FibonacciExample2{
static int n1=0,n2=1,n3=0;
static void printFibonacci(int count){
if(count>0){
n3 = n1 + n2;
n1 = n2;
n2 = n3;
System.out.print(" "+n3);
printFibonacci(count-1);
}
}
 public static void main(String args[]){
int count=10;
System.out.print(n1+" "+n2);//printing 0 and 1
printFibonacci(count-2);//n-2 because 2 numbers are already printed
}
}
66. Write a Java program to check if the two strings are anagrams.
import java.util.Arrays;
public class AnagramString {
static void isAnagram(String str1, String str2) {
String s1 = str1.replaceAll("\\s", "");
String s2 = str2.replaceAll("\\s", "");
boolean status = true;
if (s1.length() != s2.length()) {
status = false;
} else {
char[] ArrayS1 = s1.toLowerCase().toCharArray();
char[] ArrayS2 = s2.toLowerCase().toCharArray();
Arrays.sort(ArrayS1);
Arrays.sort(ArrayS2);
status = Arrays.equals(ArrayS1, ArrayS2);
}
if (status) {
System.out.println(s1 + " and " + s2 + " are anagrams");
} else {
System.out.println(s1 + " and " + s2 + " are not anagrams");
}
}
public static void main(String[] args) {
isAnagram("Keep", "Peek");
isAnagram("Mother In Law", "Hitler Woman");
}
}
Output

Keep and Peek are anagrams

MotherInLaw and HitlerWoman are anagrams

67. Write a Java Program to find the factorial of a given number.

4! = 4*3*2*1 = 24

5! = 5*4*3*2*1 = 120

68. Given an array of non-duplicating numbers from 1 to n where one number is

missing, write an efficient java program to find that missing number.
Input: arr[] = {1, 2, 4, 6, 3, 7, 8}, N = 8

Output: 5

Explanation: The missing number between 1 to 8 is 5

69. Write a Java Program to check if any number is a magic number or not. A number
is said to be a magic number if after doing the sum of digits in each step and in
turn doing the sum of digits of that sum, the ultimate result (when there is only
one digit left) is 1.
// Java program to check if
// a number is Magic number.
class GFG
{
public static boolean isMagic(int n)
{
int sum = 0;
// Note that the loop continues
// if n is 0 and sum is non-zero.
// It stops when n becomes 0 and
// sum becomes single digit.
while (n > 0 || sum > 9)
{
if (n == 0)
{
n = sum;
sum = 0;
}
sum += n % 10;
n /= 10;
}

// Return true if sum becomes 1.

return (sum == 1);
}
// Driver code
public static void main(String args[])
{
int n = 1234;
if (isMagic(n))
System.out.println("Magic Number");

else
System.out.println("Not a magic Number");
}
}
class InvalidAgeException extends Exception
{
public InvalidAgeException (String str)
{
// calling the constructor of parent Exception
super(str);
}
}
70. Write a Java program to create and throw custom exceptions.
// class that uses custom exception InvalidAgeException
public class TestCustomException1
{
// method to check the age
static void validate (int age) throws InvalidAgeException{
if(age < 18){
// throw an object of user defined exception
throw new InvalidAgeException("age is not valid to vote");
}
else {
System.out.println("welcome to vote");
}
}
// main method
public static void main(String args[])
{
try
 {
// calling the method
validate(13);
}
catch (InvalidAgeException ex)
{
System.out.println("Caught the exception");

// printing the message from InvalidAgeException object

System.out.println("Exception occured: " + ex);
}
System.out.println("rest of the code...");
}
}
71. Write a Java program to rotate arrays 90 degree clockwise by taking matrices
from user input.
public class RotateMatrixClockwise
{
public static void main(String args[])
{
//matrix to rotate
int a[][]= {{1,2,3},{4,5,6},{7,8,9}};
System.out.println("Original Matrix: \n");
//loop for rows
for(int i=0;i<3;i++)
{
//loop for columns
for(int j=0;j<3;j++)
{
//prints the elements of the original matrix
System.out.print(" "+a[i][j]+"\t");
}
System.out.println("\n");
}
System.out.println("Rotate Matrix by 90 Degrees Clockwise: \n");
for(int i=0;i<3;i++)
{
for(int j=2;j>=0;j--)
{
//prints the elements of the rotated matrix
System.out.print(""+a[j][i]+"\t");
}
System.out.println("\n");
}
}
}
72. Write a java program to check if any number given as input is the sum of 2
prime numbers.
// C program to check if a prime number
// can be expressed as sum of
// two Prime Numbers
#include <stdio.h>
#include <math.h>
#include <stdbool.h>
// Function to check whether a number
// is prime or not
bool isPrime(int n)
{
if (n <= 1)
 return false;
for (int i = 2; i <= sqrt(n); i++)
{
if (n % i == 0)
return false;
}
return true;
}
// Function to check if a prime number
// can be expressed as sum of
// two Prime Numbers
bool isPossible(int N)
{
// if the number is prime,
// and number-2 is also prime
if (isPrime(N) && isPrime(N - 2))
return true;
else
return false;
}
// Driver code
int main()
{
int n = 13;

if (isPossible(n))
printf("%s", "Yes");
else
printf("%s", "No");

return 0;
}
73. Write a Java program for solving the Tower of Hanoi Problem.
// Java recursive program to solve tower of hanoi puzzle
class GFG
{
// Java recursive function to solve tower of hanoi puzzle
static void towerOfHanoi(int n, char from_rod, char to_rod, char
aux_rod)
{
if (n == 1)
{
System.out.println("Move disk 1 from rod
" + from_rod + " to rod " +to_rod);
return;
}
towerOfHanoi(n-1, from_rod, aux_rod, to_rod);
System.out.println("Move disk " + n + " from rod " +
from_rod + " to rod " +to_rod);
towerOfHanoi(n-1, aux_rod, to_rod, from_rod);
}
// Driver method
public static void main(String args[])
{
int n = 4; // Number of disks
towerOfHanoi(n, \'A\', \'C\', \'B\'); // A, B and C are
names of rods
}
}
74. Implement Binary Search in Java using recursion.
// Java Program to Illustrate Recursive Binary Search
// Importing required classes
import java.util.*;
// Main class
class GFG {
// Method 1
// Recursive binary search
// Returns index of x if it is present
// in arr[l..r], else return -1
int binarySearch(int arr[], int l, int r, int x)
{
// Restrict the boundary of right index
// and the left index to prevent
// overflow of indices
if (r >= l && l <= arr.length - 1) {
int mid = l + (r - l) / 2;
// If the element is present
// at the middle itself
if (arr[mid] == x)
return mid;
// If element is smaller than mid, then
it can
// only be present in left subarray
if (arr[mid] > x)
return binarySearch(arr, l,
mid - 1, x);

// Else the element can only be present

// in right subarray
return binarySearch(arr, mid + 1, r, x);
}
// We reach here when element is not present in
// array
return -1;
}
// Method 2
// Main driver method
public static void main(String args[])
{
// Creating object of above class
GFG ob = new GFG();
// Custom input array
int arr[] = { 2, 3, 4, 10, 40 };

// Length of array
int n = arr.length;
// Custom element to be checked
// whether present or not
int x = 10;
// Calling above method
int result = ob.binarySearch(arr, 0, n - 1, x);
// Element present
if (result == -1)
// Print statement
System.out.println("Element not
present");

// Element not present

 else
// Print statement
System.out.println("Element found at
index "

+ result);
}
}
75. Is delete, next, main, exit or null keyword in java?
No, these keywords do not exist in Java. Delete, Next, Exit are the operations
performed in the Java program, Main is the predefined method, and Null is the
default String type.

With this we are done with the first section that is Basic Java Interview Question,
Now, lets move on to our next section of Intermediate Java Interview Questions.

Take the Leap and Master Java Development

Java Certification TrainingENROLL NOWTake the Leap and Master Java Development
Java Coding Interview Questions For Intermediate
Now, let's have a look at some of the most asked Java technical interview questions
for intermediate experienced professionals.

76. What is JDK? Mention the variants of JDK?

JDK is an abbreviation for Java Development Kit. It is a combined Package of JRE
and Developer tools used for designing Java Applications and Applets. Oracle has
the following variants.

JDK Standard Edition

JDK Enterprise Edition
JDK Micro Edition
77. What is the difference between JDK, JRE, and JVM?
JVM has a Just in Time (JIT) compiler tool that converts all the Java source code
into the low-level compatible machine language. Therefore, it runs faster than the
regular application.

JRE has class libraries and other JVM supporting files. But it doesn’t have any
tool for java development such as compiler or debugger.

JDK has tools that are required to write Java Programs and uses JRE to execute
them. It has a compiler, Java application launcher, and an applet viewer.

78. What is a JIT compiler?

JIT compiler refers to Just in Time compiler. It is the simplest way of executing
the computer code that takes in compilation during the execution of a program
rather than before performance. It commonly uses bytecode translation to machine
code. It is then executed directly.

79. What are Brief Access Specifiers and Types of Access Specifiers?
Access Specifiers are predefined keywords used to help JVM understand the scope of
a variable, method, and class. We have four access specifiers.

Public Access Specifier

Private Access Specifier
Protected Access Specifier
Default Access Specifier
80. How many types of constructors are used in Java?
There are two types of constructors in Java.

Parameterized Constructors: Parameterized constructor accepts the parameters with

which users can initialize the instance variables. Users can initialize the class
variables dynamically at the time of instantiating the class.

Default constructors: This type doesn’t accept any parameters; rather, it

instantiates the class variables with their default values. It is used mainly for
object creation.

81. Can a constructor return a value?

Yes, A constructor can return a value. It replaces the class's current instance
implicitly; you cannot make a constructor return a value explicitly.

82. Explain ‘this’ keyword in Java.

The term "this" is a particular keyword designated as a reference keyword. The
"this" keyword is used to refer to the current class properties like method,
instance, variable, and constructors.

83. Explain ‘super’ keyword in Java.

The term "super" is a particular keyword designated as a reference keyword. The
"super" keyword refers to the immediate parent class object.

84. Explain Method Overloading in Java.

The process of creating multiple method signatures using one method name is called
Method Overloading in Java. Two ways to achieve method overloading are:

Varying the number of arguments

Changing the return type of the Method
85. Can we overload a static method?
No, Java does not support the Overloading of a static method. The process would
throw an error reading "static method cannot be referenced."

86. Define Late Binding.

Binding is a process of unifying the method call with the method's code segment.
Late binding happens when the method's code segment is unknown until it is called
during the runtime. Get access and complete hands-on experience on a plethora of
software development skills in our unique Job Guarantee bootcamp. Get job-ready by
enrolling in our comprehensive Full Stack Java Developer Masters program today!
87. Define Dynamic Method Dispatch.
The Dynamic method dispatch is a process where the method call is executed during
the runtime. A reference variable is used to call the super-class. This process is
also known as Run-Time Polymorphism.

88. Why is the delete function faster in the linked list than an array?
Delete Function is faster in linked lists in Java as the user needs to make a minor
update to the pointer value so that the node can point to the next successor in the
list

89. Give a briefing on the life cycle of a thread.

The life cycle of a thread includes five stages, as mentioned below.

New Born State

Runnable State
Running State
Blocked State
Dead State
90. Explain the difference between >> and >>> operators.
Although they look similar, there is a massive difference between both.

>> operator does the job of right shifting the sign bits
>>> operator is used in shifting out the zero-filled bits
91. Brief the life cycle of an applet.
The life cycle of an applet involves the following.

Initialization
Start
Stop
Destroy
Paint
92. Why are generics used in Java Programming?
Compile-time type safety is provided by using generics. Compile-time type safety
allows users to catch unnecessary invalid types at compile time. Generic methods
and classes help programmers specify a single method declaration, a set of related
methods, or related types with an available class declaration.

93. Explain the Externalizable interface.

The Externalizable interface helps with control over the process of serialization.
An "externalisable" interface incorporates readExternal and writeExternal methods.

94. What is the Daemon Thread?

The Daemon thread can be defined as a thread with the least priority. This Daemon
thread is designed to run in the background during the Garbage Collection in Java.

The setDaemon() method creates a Daemon thread in Java.

95. Explain the term enumeration in Java.

Enumeration or enum is an interface in Java. Enum allows the sequential access of
the elements stored in a collection in Java.

96. Why is Java is Dynamic?

Java is designed to adapt to an evolving environment. Java programs include a large
amount of runtime information that is used to resolve access to objects in real-
time.

97. Can you run a code before executing the main method?
Yes, we can execute any code, even before the main method. We will be using a
static block of code when creating the objects at the class's load time. Any
statements within this static block of code will get executed at once while loading
the class, even before creating objects in the main method.

98. How many times is the finalize method called?

The finalize method is called the Garbage collector. For every object, the Garbage
Collector calls the finalize() method just for one time.

Related Software Developer Interview Guides

Coding

Frontend Developer
Python

Java 8

Node.js

JavaScript

Angular

ReactJS
Spring Boot

Core Java Interview Questions for Experienced

Now, let's move on to our last section of Advanced Core Java Interview Questions,
which is primarily useful for experienced and working professionals.

99. Can "this" and "super" keywords be used together?

No, "this" and "super" keywords should be used in the first statement in the class
constructor. The following code gives you a brief idea.

public class baseClass {

baseClass() {
super();
this();
System.out.println(" baseClass object is created");
}
public static void main(String []args){
baseClass bclass = new baseClass();
}
}
100. What is a JSP page?
JSP is an abbreviation for Java Servlet Page. The JSP page consists of two types of
text.

Static Data
JSP elements
101. What is JDBC?
JDBC is an abbreviation for Java Database Connector.

JDBC is an abstraction layer used to establish connectivity between an existing

database and a Java application

102. Explain the various directives in JSP.

Directives are instructions processed by JSP Engine. After the JSP page is compiled
into a Servlet, Directives set page-level instructions, insert external files, and
define customized tag libraries. Directives are defined using the symbols below:

start with "< %@" and then end with "% >"

The various types of directives are shown below:

Include directive
It includes a file and combines the content of the whole file with the currently
active pages.

Page directive
Page Directive defines specific attributes in the JSP page, like the buffer and
error page.

Taglib
Taglib declares a custom tag library, which is used on the page.

103. What are the observer and observable classes?

Objects that inherit the "Observable class" take care of a list of "observers."

When an Observable object gets upgraded, it calls the update() method of each of
its observers.
After that, it notifies all the observers that there is a change of state.

The Observer interface gets implemented by objects that observe Observable objects.

104. What is Session Management in Java?

A session is essentially defined as the random conversation's dynamic state between
the client and the server. The virtual communication channel includes a string of
responses and requests from both sides. The popular way of implementing session
management is establishing a session ID in the client's communicative discourse and
the server.

105. Briefly explain the term Spring Framework.

Spring is essentially defined as an application framework in Java and inversion of
control containers for Java. The spring framework creates enterprise applications
in Java. Especially useful to keep in mind that the spring framework's central
features are essentially conducive to any Java application.

106. How to handle exceptions in Spring MVC Framework?

Spring MVC has two approaches for handling the exceptions:

Exception handler method: In this kind of exception handling, the user will get the
@ExceptionHandler annotation type used to annotate a method to handle exceptions.
XML Configuration: The user can use the SimpleMappingExceptionResolver bean in
Spring’s application file and map the exception.
107. What is JCA in Java?
Java Cryptography Architecture gives a platform and provides architecture and
application programming interfaces that enable decryption and encryption.

Developers use Java Cryptography Architecture to combine the application with the
security applications. Java Cryptography Architecture helps in implementing third
party security rules and regulations.

Java Cryptography Architecture uses the hash table, encryption message digest, etc.
to implement the security.

108. Explain JPA in Java.

The Java Persistence API enables us to create the persistence layer for desktop and
web applications. Java Persistence deals in the following:

Java Persistence API

Query Language
Java Persistence Criteria API
Object Mapping Metadata
109. Explain the different authentications in Java Servlets.
Authentication options are available in Servlets: There are four different options
for authentication in servlet:

Basic Authentication:
Usernames and passwords are given by the client to authenticate the user.

Form-based authentication:
In this, the login form is made by the programmer by using HTML.

Digest Authentication:
It is similar to basic authentication, but the passwords are encrypted using the
Hash formula. Hash Formula makes digest more secure.

Client certificate Authentication:

It requires that each client accessing the resource has a certificate that it sends
to authenticate itself. Client Authentication requires the SSL protocol.

110. Explain FailFast iterator and FailSafe iterator along with examples for each.
FailFast iterators and FailSafe iterators are used in Java Collections.

FailFast iterators do not allow changes or modifications to the Java Collections,

which means they fail when the latest element is added to the collection or an
existing element gets removed from the collection. The FailFast iterators tend to
fail and throw an exception called ConcurrentModificationException.

Ex: ArrayList, HashMap

Whereas, on the other hand, FailSafe iterators allow changes or modifications to be

done on the Java Collections. It is possible, as the FailSafe iterators usually
operate on the cloned copy of the collection. Hence, they do not throw any specific
exception.

Ex: CopyOnWriteArrayList

111. How do we reverse a string?

The string can be reversed by using the following program.

package simplilearnJava;
public class StringReverse {
public static void main(String args[]) {
String str = "Simplilearn";
String reverse = new StringBuffer(str).reverse().toString();
System.out.printf("Actual Word: %s, Word after reversing %s", str, reverse);
}
public static String reverse(String source) {
if (source == null || source.isEmpty()) {
return source;
}
String reverse = "";
for (int i = source.length() - 1; i >= 0; i--) {
reverse = reverse + source.charAt(i);
}
return reverse;
}
}
Expected Output:

Actual Word: Simplilearn, Word after reversing nraelilpmiS

112. Write a program to find the square root of a number.

The Square root of a number can be found by using the following program.

package simplilearnJava;
import java.util.Scanner;
public class SRoot {
public static void main(String args[]) {
try (Scanner sc = new Scanner(System.in)) {
System.out.println("Input a number to find square root: ");
double square = sc.nextDouble();
double squareRoot = Math.sqrt(square);
System.out.printf("The square root is: %f ", squareRoot);
}
}
}
Expected Output:

Input a number to find square root:

25

The square root is: 5

113. Write a program that detects the duplicate characters in a string.

The program that finds the duplicate elements in a string is written below:

package simplilearnJava;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class FindDuplicate {
public static void main(String args[]) {
printDuplicateCharacters("Simplilearn");
}
public static void printDuplicateCharacters(String word) {
char[] characters = word.toCharArray();
Map<Character, Integer> charMap = new HashMap<Character, Integer>();
for (Character ch : characters) {
if (charMap.containsKey(ch)) {
charMap.put(ch, charMap.get(ch) + 1);
} else {
charMap.put(ch, 1);
}
}
Set<Map.Entry<Character, Integer>> entrySet = charMap.entrySet();
System.out.printf("List of duplicate characters in String '%s' %n", word);
for (Map.Entry<Character, Integer> entry : entrySet) {
if (entry.getValue() > 1) {
System.out.printf("%s: %d %n", entry.getKey(), entry.getValue());
}
}
}
}
Expected output:

List of duplicate characters in String 'Simplilearn.'

i: 2

l: 2

114. Write a Program to remove duplicates in an ArrayList.

The following program can be implemented to remove duplicate elements in an
ArrayList

package simplilearnJava;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class ArrayDuplicate {
public static void main(String args[]) {
List<Integer> num = new ArrayList<Integer>();
num.add(1);
num.add(2);
num.add(3);
num.add(4);
num.add(5);
num.add(6);
num.add(3);
num.add(4);
num.add(5);
num.add(6);
System.out.println("Your list of elements in ArrayList : " + num);
Set<Integer> primesWithoutDuplicates = new LinkedHashSet<Integer>(num);
num.clear();
num.addAll(primesWithoutDuplicates);
System.out.println("list of original numbers without duplication: " + num);
}
}
Expected Output:

Your list of elements in ArrayList : [1, 2, 3, 4, 5, 6, 3, 4, 5, 6]

list of original numbers without duplication: [1, 2, 3, 4, 5, 6]

115. Find the word count in a string using HashMap Collection.

The following program can be used for word count.

package simplilearnJava;
import java.util.HashMap;
public class WordCount {
public static void main(String[] args) {
String str = "Hello World, Welcome to Simplilearn";
String[] split = str.split(" ");
HashMap<String, Integer> map = new HashMap<String, Integer>();
for (int i = 0; i < split.length; i++) {
if (map.containsKey(split[i])) {
int count = map.get(split[i]);
map.put(split[i], count + 1);
} else {
map.put(split[i], 1);
}
}
System.out.println(map);
}
}
Expected Output:

{Hello=1, Simplilearn=1, Welcome=1, to=1, World,=1}

116. Write a program to find the Second Highest number in an ArrayList

The following program can be used to find the second biggest number in an array
list.

package simplilearnJava;
public class NextHighest {
public static void main(String[] args)
{
int array[] = { 1, 2, 3, 4, 11, 12, 13, 14, 21, 22, 23, 24, 31, 32};
int high = 0;
int nextHigh = 0;
System.out.println("The given array is:");
 for (int i = 0; i < array.length; i++)
{
System.out.print(array[i] + "\t");
}
for (int i = 0; i < array.length; i++)
{
if (array[i] > high)
{
nextHigh = high;
high = array[i];
}
else if (array[i] > nextHigh)
{
nextHigh = array[i];
}
}
System.out.println("Second Highest is:" + nextHigh);
System.out.println("Highest Number is: " +high);
}
}
Expected Output:

The given array is:

1 2 3 4 11 12 13 14 21 22 23 24 31 32

Second Highest is:31

The highest number is: 32

117. What is the difference between System.out, System.err, and System.in?

System.out and System.err represent the monitor by default and thus can be used to
send data or results to the monitor. System.out is used to display normal messages
and results. System.eerr is used to display error messages. System.in represents
InputStream object which by default represents standard input device, i.e.,
keyboard.

118. Could you provide some implementation of a Dictionary having a large number of
words?
The simplest implementation that can be given is that of a List wherein one can
place ordered words and perform a Binary search. The other implementation with a
better search performance is HashMap where the key is used as the first character
of the word and the value as a LinkedList.

Up another level, there are HashMaps like:

hashmap {

a (key) -> hashmap (key-aa , value (hashmap(key-aaa,value)

b (key) -> hashmap (key-ba , value (hashmap(key-baa,value)

z (key) -> hashmap (key-za , value (hashmap(key-zaa,value)

Up to n levels where n is the average size of the word in the dictionary.

119. How would you tackle it if you might have to encounter pattern programs in
Java?
To tackle pattern programs in Java, you need a strong understanding of loops (for,
while) and nested loops. Pattern programs generally involve printing shapes like
triangles, pyramids, or grids using characters or numbers, which can be achieved by
controlling row and column iterations with loops. By carefully managing loop
conditions, you can manipulate spaces, characters, or numbers to create the desired
patterns.

120. What do you understand by an instance variable and a local variable?

Dive Deep Into Java Core Concepts
Java Certification TrainingENROLL NOWDive Deep Into Java Core Concepts
Generally, instance variables are declared in a class but outside methods whereas a
local variable is declared within the blocks of code.

//Local Variable
import Java.io.*;
class Main {
public static void main(String[] args)
{
int var = 145;
System.out.println("Local Variable: " + var);
}
}
//Instance variable
import Java.io.*;
class Main {
public int value = 12;
public static void main(String[] args)
{
Main va = new Main();
System.out.println("My value is: " + va.value);
}
}
121. Can the main method be overloaded?
Yes, the main method can be overloaded as many times as we want. Nevertheless, JVM
prefers to call the main method with the help of its predefined calling method.

Example:

class Main {
public static void main(String args[]) {
System.out.println(" Main Method");
}
public static void main(int[] args){
System.out.println("Overloaded Integer array Main Method");
}
public static void main(char[] args){
System.out.println("Overloaded Character array Main Method");
}
public static int main(double[] args){
System.out.println("Overloaded Double array Main Method");
}
public static void main(float args){
System.out.println("Overloaded float Main Method");
}
}
122. Comment on method overloading and overriding by citing relevant examples.
Method overloading occurs during the compile time, whereas method overriding occurs
during the run time. Static binding is used during overloading, whereas dynamic
binding is used during methods overriding.

//Function overloading
#function1
void addPodium(int a, int b)
{
System.out.println(a + b);
}
#function2
float addPodium(float a, float b, float c)
{
System.out.println(a + b + c);
}
//Function overriding
class Parent {
void show()
{
System.out.println("I am Parent");
}
}
class Child extends Parent {
void show()
{
System.out.println("I am Child");
}
}
class Main {
public static void main(String[] args)
{
Parent obja = new Parent();
obja.show();
Parent objb = new Child();
objb.show();
}
}
123. A single try block and multiple catch blocks can co-exist in a Java Program.
Explain.
One or more catch blocks can follow a try block. Each catch block must have a
unique exception handler. So, if you want to perform multiple tasks in response to
various exceptions, use the Java multi-catch block.

124. Do final, finally and finalize keywords have the same function?
No, final, finally and finalize keywords have different functionalities.

Final is used to restrict classes, variables, or methods, the final keyword.

Finally is used to execute the code written inside the block without handling any
exceptions.

Finalize is used to call the function of the implementation of cleaning the garbage
collection of an object.

125. When can you use the "super" keyword?

Basically, the super keyword is used to refer to the parent class. When there are
the same fields in both parent and child classes, then one can use a super keyword
to access data members of the parent class.

126. What are shallow copy and deep copy in Java?

In a shallow copy, primitive data types are copied, whereas in a deep copy, along
with primitive data types, object references are also copied.

127. Using relevant properties highlight the differences between interfaces and
abstract classes.
An abstract class can have a combination of both abstract and non-abstract methods,
whereas an interface has only abstract methods in it.

128. What are the different ways of thread usage?

There are two ways to define and implement a thread in Java. They are by
implementing the runnable interface and extending the thread class.

Extending the Thread class

class InterviewBitThreadExample extends Thread{
public void run(){
System.out.println("Thread runs...");
}
public static void main(String args[]){
InterviewBitThreadExample ib = new InterviewBitThreadExample();
ib.start();
}
}
Implementing the Runnable interface
class InterviewBitThreadExample implements Runnable{
public void run(){
System.out.println("Thread runs...");
}
public static void main(String args[]){
Thread ib = new Thread(new InterviewBitThreadExample());
ib.start();
}
}
Implementing a thread using the Runnable interface method is preferred and
advantageous as Java does not support multiple inheritances of classes.

The start() method creates a separate call stack for thread execution. Once the
call stack is created, the JVM calls the run() method to execute the thread in that
call stack.

129. What is the difference between the ‘throw' and ‘throws' keyword in Java?
The throw keyword is often used to explicitly throw an exception. It can only throw
one exception at a time whereas throws can be used to declare multiple exceptions.

130. Identify the output of the below Java program and Justify your answer.
class Main {
public static void main(String args[]) {
Simplilearn s = new Simplilearn(5);
}
}
class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class Simplilearn extends InterviewBit{
Simplilearn(){
System.out.println(" Welcome to Simplilearn ");
}
Simplilearn(int x){
this();
 super();
System.out.println(" Welcome to Simplilearn 2");
}
}
The above code will throw the compilation error. It is because the super() is used
to call the parent class constructor. But there is the condition that super() must
be the first statement in the block. Now, in this case, if we replace this() with
super(), it will also throw a compilation error. Because this() also must be the
block's first statement. So, in conclusion, we can say that we cannot use this()
and super() keywords in the same block.

131. Java works as a “pass by value” or “pass by reference” phenomenon?

Java works as a “pass by value” phenomenon, because “pass by reference” needs the
help of pointers. But there are no pointers in Java.

132. How to not allow serialization of attributes of a class in Java?

One approach to not allowing serialization of a class's attributes in Java is to
use the writeObject() and readObject() methods in the subclass and throw a not
Serializable exception.

133. What are the default values assigned to variables and instances in Java?
By default, for a numerical value it is 0, for the boolean value it is false and
for objects it is NULL.

134. What do you mean by data encapsulation?

Data encapsulation is one of the properties of OOPS concepts, where all the data
such as variables and methods are enclosed together as a single unit.

135. Can you tell the difference between equals() method and equality operator (==)
in Java?
The equality operator (= =) is used to check the equality condition between two
variables, but the equals() method is used to check the equality condition between
two objects.

Become job-ready by opting for the decade's hottest career option. Score your dream
job in no time by enrolling in our Full Stack Java Developer Program Today!
136. How is an infinite loop declared in Java?
An infinite loop can be declared in Java by breaking the logic in the instruction
block. For example,

for(int i = 1; i > 0; i++)

{
//statements
}

The above code forms an infinite loop in Java.

137. Briefly explain the concept of constructor overloading

The concept of constructor overloading refers to having multiple methods in a class
with their name being the same as the class name. The difference lies in the set of
parameters passed to the functions.

138. Explain the use of the final keyword in variable, method and class.
In Java, one can apply the final keyword to a variable, methods, and class. With
the help of the final keyword, the variable turns out to be a constant, the method
cannot be inherited and the class cannot be overridden.

139. Is it possible that the ‘finally' block will not be executed? If yes then list
the case.
Yes, there is a possibility that the ‘finally’ block cannot get executed. Here are
some of the cases where the above situation occurs.

During the time of fatal errors such as memory exhaustion, memory access error,
etc.
During the time of using System.exit()
140. Difference between static methods, static variables, and static classes in
Java.
A variable, method, or class can be made static by using the static keyword. A
static class cannot be instantiated. When both objects or instances of a class
share the same variables, this is referred to as static variables. Static methods
are simply methods that refer to the class in which they are written.

141. What is the main objective of garbage collection?

The main goal of using garbage collection is to free the heap memory by eliminating
unnecessary objects.

142. Apart from the security aspect, what are the reasons behind making strings
immutable in Java?
Because of security, synchronization, concurrency, caching, and class loading, the
String is immutable in Java. The reason for making string final would be to destroy
its immutability and help stop others from trying to extend it. String objects are
cached in the String pool, making them immutable.

143. Which of the below generates a compile-time error? State the reason.
int[] n1 = new int[0];
boolean[] n2 = new boolean[-200];
double[] n3 = new double[2241423798];
char[] ch = new char[20];
We get a compile-time error in line 3. The error we will get in Line 3 is - the
integer number too large. It is because the array requires size as an integer. And
Integer takes 4 Bytes in the memory. And the number (2241423798) is beyond the
capacity of the integer. The maximum array size we can declare is - (2147483647).

Because the array requires the size in integer, none of the lines (1, 2, and 4)
will give a compile-time error. The program will compile fine. But we get the
runtime exception in line 2. The exception is - NegativeArraySizeException.

Here what will happen is - At the time when JVM will allocate the required memory
during runtime then it will find that the size is negative. And the array size
can’t be negative. So the JVM will throw the exception.

144. How would you differentiate between a String, StringBuffer, and a

StringBuilder?
The string class is immutable but the other two are mutable in nature. StringBuffer
is synchronous whereas the StringBuilder is asynchronous. String uses string pool
as memory storage whereas the other two use heap memory for storage purposes.

145. What is a Comparator in Java?

A comparator is an interface, which is used to sort the objects.

146. In Java, static as well as private method overriding is possible. Comment on

the statement.
In Java, you could indeed override a private or static method. If you create a
similar method in a child class with the same return type and method arguments, it
will hide the super class method; this is known as method hiding. Similarly, you
cannot override a private method in a subclass because it is not accessible from
that.
147. What makes a HashSet different from a TreeSet?
In a HashSet, the elements are unsorted and work faster than a Tree set. It is
implemented using a hash table.

148. Why is the character array preferred over string for storing confidential
information?
Because Strings are immutable, any change will result in the creation of a new
String, whereas char[] allows you to set all of the elements to blank or zero. So
storing a password in a character array clearly reduces the security risk of
password theft.

149. What are the differences between HashMap and HashTable in Java?
HashMap

HashTable

1. Asynchronous in nature

1. Synchronous in nature

2. Not thread-safe

2. Thread safe

3. It allows one null key and null values

3. It doesn’t allow null keys and values.

150. What is the importance of reflection in Java?

Reflection is a property of Java, enabling the Java code to inspect itself. A Java
class, for example, can get the names of all its members and showcase them.

151. What are the different types of Thread Priorities in Java? And what is the
default priority of a thread assigned by JVM?
There are different types of thread properties in Java. They are MIN_PRIORITY,
MAX_PRIORITY, and NORM_PRIORITY. By default, the thread is assigned NORM_PRIORITY.

152. What is the ‘IS-A ‘ relationship in OOPs Java?

‘IS-A’ relationship is related to the Inheritance property of OOPs Java. It is a
kind of parent-child relationship that is established between two classes.

153. Why is Java, not a pure object-oriented language?

It is not a pure object-oriented language because it supports primitive data types
like int, double, and char, which are not objects, and it supports static methods
and variables.

154. Can static methods be overridden?

No, static methods cannot be overridden in Java.

155. What are the different ways of thread usage?

Two ways to use threads in Java one is by extending the Thread class or by
implementing the Runnable interface. Another way to use threads in Java is by using
the Executor framework, which provides a higher level of abstraction for managing
threads.

156. How do you achieve Object Cloning in Java?

Creating a new object with the same state as an existing object called Object
Cloning in Java. This can be achieved by implementing the Cloneable interface and
overriding the clone() method in the class.
157. What is a Java Virtual Machine?
It is an abstract machine that provides a runtime environment for Java programs to
run. The JVM interprets the compiled Java code and executes it on the underlying
operating System.

158. What gives Java its 'write once and run anywhere' nature?
Java's 'write once and run anywhere' nature is achieved by using Java Virtual
Machine (JVM) and bytecode. Java code is compiled into bytecode, which can be
executed on any platform that has a JVM installed.

159. What are the advantages of Packages in Java?

Packages in Java provide a way to organize classes and interfaces into namespaces.
This helps to avoid naming conflicts and makes it easier to manage large codebases.
Packages provide a way to create reusable code through the use of libraries.

160. Explain static variables with examples and a diagram.

A static variable in Java is a variable that is associated with the class rather
than an instance of the class. This means that all instances of the class share the
same static variable. They are declared using the static keyword.

public class Example {

static int count = 0;
public Example() {
count++;
}
}
Diagram - The diagram below illustrates the relationship between the class and the
static variable:

+----------+

Example | count=0 |

+----------+

| |

Instance1 | |

+----------+

| |

Instance2 | |

+----------+

161. Explain static block

A static block in Java is a block of code that is executed when the class is loaded
into memory. Static blocks are enclosed in curly braces and are marked with the
static keyword.

162. Difference between static (class) method and instance method

The main difference between a static method and an instance method in Java is that
a static method is associated with the class, while an instance method is
associated with an instance of the class.

163. How can constructor chaining be done using this keyword?

It is the process of calling one constructor from another constructor in the same
class. This can be achieved using this keyword.

164. Which class is the superclass for all the classes?

The Object class is the only superclass for all classes in Java.

165. Why are multiple inheritances not supported in Java?

Multiple inheritances are not supported in Java because it can lead to several
problems, including the diamond problem and name conflicts.

166. Why is method overloading not possible by changing the return type in Java?
It is not possible by changing the return type in Java because the return type of a
method is not part of its signature.

167. What is method overloading with type promotion?

Method overloading with type promotion in Java is the process of defining multiple
methods in the same class with the same name but different parameter types.

168. Can we change the scope of the overridden method in the subclass?
No, we cannot change the scope of the overridden method in the subclass.

169. Can you have virtual functions in Java?

In Java, all non-static methods are virtual functions by default.

170. What is the covariant return type?

The covariant return type is a feature introduced in Java 5 that allows a subclass
method to return a type that is a subclass of the return type of the overridden
method in the superclass.

Boost Your Career and Unlock High-Paying Jobs!

Java Certification TrainingENROLL NOWBoost Your Career and Unlock High-Paying Jobs!
171. What is the final variable?
A final variable in Java is a variable that cannot be changed once it is
initialized.

172. What is the final method?

A final method in Java is a method that cannot be overridden in a subclass.

173. What is the final class?

A final class in Java is a class that cannot be subclassed.

174. What is the final blank variable?

The final blank variable in Java is a final variable that is not initialized when
it is declared.

175. Difference between the final method and the abstract method
The main difference between a final method and an abstract method in Java is that a
final method cannot be overridden in a subclass, while an abstract method must be
overridden in a subclass.

176. Differences between Heap and Stack Memory in Java

Heap and Stack are two types of memory in Java used for storing data. Heap memory
is used for storing objects, while Stack memory is used for storing local variables
and method calls. One of the main differences between Heap and Stack memory is
their allocation and deallocation. Heap memory is allocated when an object is
created and deallocated when there are no more references to that object. Stack
memory, on the other hand, is allocated when a method is called and deallocated
when the method returns.
Another difference between Heap and Stack memory is their size. Heap memory is
larger than Stack memory because it is used for storing objects. Stack memory is
smaller because it is used for storing local variables and method calls only.

177. What do you understand about an instance variable and a local variable?
Instance variables and local variables are two types of variables in Java. Instance
variables are declared inside a class but outside any method. They are used to
store data that is specific to an object. Local variables, on the other hand, are
declared inside a method and are used to store temporary data that is required only
within that method.

One of the main differences between instance variables and local variables is their
scope. Instance variables have a larger scope than local variables. The second
difference between instance variables and local variables is their initialization.
Instance variables are initialized automatically by default values if not
initialized explicitly, while local variables must be initialized explicitly before
they can be used.

178. What is a JIT Compiler?

JIT (Just-In-Time) compiler is a part of the Java Virtual Machine (JVM) that
compiles Java bytecode into native machine code at run time.

179. Can you tell the difference between the equals() method and equality operator
(==) in Java?
Equals() method and equality operator (==) are used for comparing objects in Java.
However, they differ in their functionality. Equals() method is used to compare the
contents of two objects, while the equality operator (==) is used to compare the
references of two objects.

When we use the equality operator (==) to compare two objects, it checks if both
objects refer to the same memory location. On the other hand, when we use the
Equals() method, it checks if the contents of the two objects are equal.

equals() method

equality operator (==)

In Java, it is a binary operator.

It is a Java.lang public method.Object type.

It can be applied to derived types as well as primitive types

It can only be applied to derived types.

Primitive forms are most suitable for it.

It works best with derived types.

180. What are shallow copy and deep copy in Java?

Shallow copy and deep copy are two types of object copying in Java. SC creates a
new object with the same values as the original object, while deep copy creates a
new object with new values.
Shallow copy

Deep copy

There is no new memory allocated, so it is quick

As fresh memory is allocated, the data moves slowly.

A shallow copy costs less money.

Deep copy is very costly.

Changes in one entity have an impact on the other.

Changes in one entity do not have any impact on the other.

181. Does Java work as a "pass by value" or "pass by reference" phenomenon?

Java works as a "pass-by-value" phenomenon. This means that when we pass an object
to a method, a copy of the reference to that object is passed, not the actual
object.

For example, let's consider the following code:

public void changeValue(int x) {

x = 5;
}
int num = 10;
changeValue(num);
System.out.println(num);
In this code, we pass the value of num to the changeValue() method. However, when
we change the value of x inside the method, it does not affect the value of num
outside the method. This is because Java passes a copy of the value of num, not the
actual object.

182. Why Does Java Array Index Start with 0?

In Java, array indexing starts with 0. This is because an array is a contiguous
block of memory where each element occupies a fixed amount of space. It is the
offset from the start of the array.

Consider the following code:

int[] arr = new int[5];

arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
In this code, we declare an array of size five and assign values to each element.
The index of the first element is coming 0, and the last element index is coming 4,
which is the size of the array minus 1.

183. Can you explain the Java thread lifecycle?

Java thread life cycle consists of several states, including New, Runnable,
Blocked, Waiting, Timed Waiting, and Terminated.

The New State represents a thread that has been created but not started yet. The
Runnable state represents a thread that is ready to run but may not be scheduled to
run by the operating System. The Blocked state represents a thread that is waiting
for a monitor lock to be released. The Waiting state represents a thread that is
waiting for another thread to perform a specific action. The Timed Waiting state
represents a thread that is waiting for a specific amount of time to elapse. The
Terminated state represents a thread that has completed its execution.

184. What are the possible ways of making objects eligible for garbage collection
(GC) in Java?
In Java, objects are automatically garbage collected when they are no longer
referenced. However, we can also make objects eligible for garbage collection
manually using the System.gc() method or by setting the object reference to null.

Consider the following code:

MyObject obj = new MyObject();

obj = null;
System.gc();
In this code, we create an object of the MyObject class and then set the object
reference to null. We then call the System.gc() method to request the garbage
collector to run.

185. What are the different categories of Java Design patterns?

Java Design Patterns can be categorized into three categories: Creational,
Structural, and Behavioral.

Creational patterns are used for creating objects. Some examples of Creational
patterns are Singleton, Factory, and Abstract Factory.

Structural patterns are used for assembling objects and creating relationships
between them. Some examples of Structural patterns are Adapters, bridges, and
Composites.

Behavioral patterns are used for managing algorithms, relationships, and

responsibilities between objects. Some examples of Behavioral patterns are
Observer, Strategy, and Template Methods.

186. List the features of the Java Programming language.

Java is a popular programming language that is widely used for developing
applications. Some of the features of Java programming language are:

Platform Independence: Java code can run on any platform that has a JVM installed.
Object-Oriented: Java is an object-oriented programming language that supports
encapsulation, inheritance, and polymorphism.
Memory Management: Java has automatic memory management, which means that it
manages memory allocation and deallocation automatically.
Multithreading: Java supports multithreading, which allows multiple threads to run
concurrently.
Security: Java has built-in security features that protect the System from
malicious attacks.
Exception Handling: Java has a robust exception-handling mechanism that allows
developers to handle errors and exceptions effectively.
Garbage Collection: Java has automatic garbage collection, which means that it
automatically frees the memory.

=======================================10 Reasons That Explain Why You Need To

Learn Java
Lesson 1 of 43By Ravikiran A S
Last updated on Jul 23, 202444303
10 Reasons That Explain Why You Need to Learn Java
PreviousNext
Table of Contents
1. Beginner Friendly and Competitive Edge2. Updated features 3. Code Portability
and Versatility4. Open-source Library Support5. Java Enterprise Edition and APIView
More
In this article on 10 Reasons That Explain Why You Need To Learn Java, We will
provide you with a brief walkthrough that explains the importance of learning Java
programming in 2022.

It was in the year 1991; Sun Microsystems made history. The quest was to design a
programming language for the Television set-top box. James Gosling (father of Java)
himself would have never predicted that he was about to lay the foundations for the
IT industry's future.

Java follows the simplest and readable form of writing code with the most
sophisticated syntax of an object-oriented programming language. Not only these,
but Java claims to have multiple advantages that give it a strong edge over other
programming languages.

The first important reason out of the ten to Learn Java is Java's beginner-friendly
and competitive edge nature.

Want a Top Software Development Job? Start Here!

Full Stack Developer - MERN StackExplore ProgramWant a Top Software Development
Job? Start Here!
1. Beginner Friendly and Competitive Edge
The best part while you learn Java is its beginner-friendly nature. The syntax of
Java matches a lot with its predecessors, C, C++, etc. Of course, Java has
inherited its predecessors, but also, Java comes with some advanced features to
help programmers in real-time.

Unlike its predecessors, Java comes with advanced memory management tools. Runtime
Environment takes care of memory allocation, reallocation, and deallocation
automatically via an in-built software tool called the Garbage collector.

The object-oriented programming nature of the language makes it more precise,

readable, and the best in class when it comes to getting started with real-time
projects, even at the beginner's stage.

Moving ahead, we will learn the dramatic and updated features of the Java
programming language that makes it a dominant competitor to its allies.

2. Updated features
It is found that beginners these days are in a dilemma if they want to learn Java.
Such a dilemma is because beginners still believe the myth that says Java is an
old, outdated, and obsolete programming language.

But in reality, Java is going through an unthinkable evolution that brought up many
remarkable changes and add-ons to the programming language. The latest commercial
version of Java from the oracle corporations is the Oracle Java 15

Java 15 comprises the latest text blocks, a foreign-memory access API, hidden
classes, Z Garbage Collector, and the sealed classes previews, pattern matching,
and records. Java 15, for now, is treated as a short-term release, as it is
supposed to be operational for six months with Oracle Premier Support until JDK 16
arrives.
Up next, we will learn the most important reasons out of the ten, and the only
reason for Java to become the industry leader. That is the code portability
(platform independence) and versatility.

3. Code Portability and Versatility

Java follows a fundamental principle that worked well for Java to date. The "Write
Once, and Run Anywhere" principle. Now, Java uses a software tool that comes along
with the Java download file. It is called the Java Virtual Machine (JVM).

The primary objective of JVM is to convert the code written in the user's language
into machine level language (ByteCode), and then the interpreter will compile and
execute the code. The same protocol is followed regardless of the type of the host
operating system.

Next, the language's object-oriented nature makes Java-capable bind the data
members and data manipulating methods together. Data binding makes the data to be
more secure. Not just security, Java is also capable of working with various
resources and working over the network.

Data binding and security features make Java a most versatile programming language.

Followed by platform independence and the versatile nature of Java, we have the
open-source library support of Java.

Want a Top Software Development Job? Start Here!

Full Stack Developer - MERN StackExplore ProgramWant a Top Software Development
Job? Start Here!
4. Open-source Library Support
Java is commercialized. But most of the java features are still open-source and can
also be used for building beginner level and small-scale projects. Also, Java has a
huge and never-ending ocean of libraries and support files.

Java has the support of libraries such as Apache Commons, Google Guava, Maven, and
so on.

Moving ahead, we have the Java EE and Java API.

5. Java Enterprise Edition and API

Java's Enterprise Edition adds up the advanced features and sophisticated
specifications to Java, in collaboration with Java Standard Edition. Java EE
enables Java developers to work with advanced level and real-time projects in the
IT industry.

Apart from Java EE, the API support in Java took the programming language to the
next level. The developers in Java can integrate back-end, front-end, and
supporting libraries to create a new application. The best part is, the developers
do not have to worry about the complex internal code implementations.

Advancing, we have rich community support as the next feature.

6. Rich Community Support

Java has been around for a couple of decades now and can also be considered as one
of the oldest prevailing programming languages compared to its allies. Many
developers use Java for multiple problems. There are high chances that most of the
problems will already be available, as the solution approach could be tried and
tested already.

Apart from this, there are numerous communities and groups on the internet and
social media, respectively. The fellow developers in the communities are
enthusiastic about assisting and resolving the issues faced by other developers and
beginners.

Now, moving ahead, we have a wide range of development tools in Java.

7. Wide Range of Development Tools

So far, Java is the current IT industry leader, and the most sought programming
language for developing a wide range of software and applications.

The reason for this is that they also develop a variety of software development
tools for assistance. To name a few, we have

IntelliJ
Eclipse
Android Studio
Netbeans
Etc
Advancing to the next level, we have a major dependency on Java.

8. Enormous Applications Dependent on Java

Java is a powerful language, the reason which most of the applications, regardless
of which sector it is, are built using Java. Java is everywhere.

Multiple Applications are dependent on Java, to name a few; we have the following:

Banking Sectors
Information Technology Sectors
Software Development Sectors
Stock Markets
Financial Services
Social Media
And much more
Up next, we have the never-ending demand for Java Developers.

Want a Top Software Development Job? Start Here!

Full Stack Developer - MERN StackExplore ProgramWant a Top Software Development
Job? Start Here!
9. High Demand
Java Developers are one of the high paid developers out here in the IT industry,
and this is because of the widespread dependency on the Java Programming language.

Salaries of Java developers are mentioned below.

The average salary of Java developers in India is 6 LPA

The average salary of Java developers in the USA is 85,000 USD
Next, we learn the dominance of Java over its allies.

10. Dominant Against Allies

According to a recent survey, the Java programming language is in the top three
positions by leading against its allies.

The following charts justify the point in a much detailed way.

Dominant-against-allies-Learn-Java-2

So with that, we have reached the end of this "10 Reasons That Explain Why You Need
to Learn Java" article.
==========================================
What is Java: A Beginners Guide To Java
Lesson 2 of 43By Rahul Arun

Last updated on Jul 23, 20241087827

What is Java: A Beginners Guide To Java
PreviousNext
Table of Contents
What is Java?History of JavaWhat is Java Used For?What is Java-Based Upon?Editions
in JavaView More
Today, especially since a deadly pandemic has hit the world, the internet and
smartphones have become an integral part of our lives. We use our phones for almost
all of our daily tasks. Previously, we would shop at malls, line up at banks, and
make travel arrangements at agencies. But now, we can do all this in the comfort of
our homes using smartphones. All of this is possible because of a high-level
programming language called Java.

What is Java?
Java is an object-oriented programming language used in distributed environments on
the internet. It is a high-level language that is also easy to read and understand.
With it, developers can “write once, run anywhere” (WORA), meaning that the
compiled Java code will run on all Java-compatible platforms without the need for
recompilation.

History of Java
James Gosling and Sun Microsystems invented the Java programming language in 1991.
He had a single motto while creating the language: “Write once; run anywhere.” They
first named this language Oak because of the oak tree outside Gosling’s office.
Later, the name changed to Green, then to Java Coffee, which was named after the
coffee from Indonesia, and eventually shortened to Java in 1995.

Want a Top Software Development Job? Start Here!

Full Stack Developer - MERN StackExplore ProgramWant a Top Software Development
Job? Start Here!
What is Java Used For?
Java is widely used in web consoles, GUIs, web and mobile applications, game
development, embedded systems, and desktop applications. Apart from these, Java is
also used to develop software for devices. It is used not only in computers and
mobile devices, but even in electronic devices like televisions, air conditioners,
washing machines, and so on. Online registration forms, banking apps, and shopping
via the internet are all possible because of Java.

What is Java-Based Upon?

Java is based on C and C++. The first Java compiler was developed by Sun
Microsystems and was written in C using some libraries from C++. Java files are
converted to bit code format using a compiler that the Java interpreter then
executes. Java code runs on Java Virtual Machine (JVM)—the runtime environment.

Editions in Java
There are three editions in Java. Programmers can learn any of these editions based
on the application they want to make.

Java Standard Edition - Contains core libraries, like java.lang, java.util, etc.
Java Enterprise Edition - Includes Java APIs, like JMS, EJB, JSPs/servlets, etc.
Java Micro Edition - This edition is used to program Java in cell phones, set-top
boxes, handhelds, and so on.
The most widely used edition in Java is Java SE (Standard Edition). Java SE
encompasses the basics of Java—most applications require Standard Edition.

Java Concept and Features

Java Concepts
The essential concepts in Java are its object-oriented programming (OOPs) features.
OOP simplifies software and application development as well as maintenance by
providing some concepts such as:

Object: Object is an element or an entity that has a state and behavior. For
example, a dog can be considered an object with a color, a breed, and a name. It
has behaviors such as barking and eating.
Class: A class is a collection of multiple objects. It is a blueprint that can be
used to create as many objects as you like. Classes are used to organize code, just
like how fruits, vegetables, and clinical products are divided into different
sections in a supermarket.
Constructor: Constructor may look like a method, but it is not one. Its name is the
same as the class name, and it does not return any value.
Inheritance: Inheritance is the concept where one class acquires the properties and
the behaviors of the parent class.
Polymorphism: Polymorphism is the process of performing the same task in different
ways. It lets programmers use the same word to mean different things in different
contexts.
Abstraction: Abstraction in Java is used to hide internal details and show only the
relevant essential details.
Encapsulation: Binding or wrapping code and data together into a single unit (like
a capsule) are known as encapsulation. A Java class is an example of encapsulation.
Want a Top Software Development Job? Start Here!
Full Stack Developer - MERN StackExplore ProgramWant a Top Software Development
Job? Start Here!
Java Features
Java has several qualities and features, including:

The simple syntax that is very easy to understand and learn

Java language is robust
Eliminates errors that occur in the C and C++ languages
Java comprises of features like garbage collectors and exception handling
As a portable language, Java can run on any platform
Java is secure and can perform multitasking
Java is not as fast as C and C++, but it provides higher performance than any other
language
Now that we have discussed the different features of Java, let’s see the different
components of the Java programming language.

Components of Java
There are three main components of the Java programming language, including:

JVM: The Java Virtual Machine or JVM is a platform-independent Java component that
provides an environment for executing Java programs. So, JVM loads the code,
validates the code, executes the code, and provides a runtime environment.
JRE: The Java Runtime Environment or JRE builds an environment in which the Java
files can be run and executed. It is a software package that contains JVM along
with Java class libraries and Java class loader.
JDK: The Java Development Kit or JDK is a superset of JRE and is a software
development environment used to develop Java applications and applets. The JDK
includes a private JVM and a few other resources to finish the development of a
Java application.
Java OOPs Concepts
There are four main concepts of object-oriented programming (OOP), including:

1. Abstraction
Abstraction means showing the relevant details and hiding all the backend or
internal details. In the example below, for a student to be admitted into the
college, the relevant details asked will be the name, address, parent’s name, and
high school marks. Details like favorite sports, food, or movies are not relevant.

oops-command

2. Encapsulation
Encapsulation is similar to a capsule. The entire code and all of the data are
bound together in a single unit. All the methods and variables are stored under one
class name, and the same class object can use it.

encapsulation

3. Polymorphism
Polymorphism means one task is performed in different ways. One function is used
for different tasks. In the example below, Method draw() can be used in different
places to draw different shapes, like a triangle, rectangle, or circle.

polymorphism

4. Inheritance
When one class inherits certain properties and attributes of other classes, it is
known as inheritance. There is always a superclass and a subclass. The subclass
inherits attributes from the superclass. In the example below, the animal is a
superclass that has attributes eat() and sleep(). Subclasses reptile, mammal, and
human inherit these attributes.

inheritence

Want a Top Software Development Job? Start Here!

Full Stack Developer - MERN StackExplore ProgramWant a Top Software Development
Job? Start Here!
How to Learn Java?
Java is one of the most used programming languages, mainly because Java is
naturally versatile, reliable, and compatible. So, it’s the in-demand skill to have
if you want to start a career in programming. Here are some tips to get started:

Start with the basics of Java programming (variables, data types, conditional
statements, arrays, loops, functions)
Read a book on Java Programming to understand the basic concepts
Learn the advanced topics (object-oriented programming, inheritance, abstract
class, Java interface, collections, abstract classes, exceptional handling, wrapper
classes)
Practice coding regularly to know to learn from experience
Read articles and new documentation on Java to stay up to date
Developers often ask themselves a question at some point in their career—Do I need
a Java certification?

Some employers do value certifications a lot. Earning a certification will help you
grow in your career and earn more.

Java professionals gain experience from working on projects across a range of

industries. So, they learn about the needs of different sectors as well as how they
work with developers. On the other hand, some employers value their employees more
if they have a Java certification because it adds value to the company.

There are four types of certification levels mentioned within Oracle’s Java
certification path:

Oracle Certified Associate (OCA)

Oracle Certified Professional (OCP)
Oracle Certified Expert (OCE)
Oracle Certified Master (OCM)
Choose whichever is suitable for you. The main goal of the Oracle Java
Certification exams is to test your knowledge and capabilities on prospective jobs
in the Java industry.

Become job-ready and get complete job assistance by opting for the decade's hottest
career option. Score your dream job in no time by enrolling in our Full Stack Java
Developer Job Guarantee Program Today!
Hello World Program in Java

hello world

Output:

javac

Swap two numbers without using a temporary variable

temp-variable

Output:

javac-output

Conclusion
Almost everything we use in our day-to-day life is now connected to Java. Java
programming language continues to be one of the top technologies in the industries,
and the job demand is significantly high. If you want to learn Java and start your
career in it, do refer to the following playlist link: Java Tutorials.