Java Interview Questions for Freshers

Java is a versatile and powerful programming language that has been a cornerstone of the software development industry for decades. Known for its platform independence, object-oriented nature, and robustness, Java is widely used in various domains, from web and mobile applications to enterprise software and scientific computing. For those starting their journey in Java, it’s essential to understand the basics of the language, including its syntax, core concepts, and standard libraries. Numerous online resources, tutorials, and coding boot camps are available to help beginners grasp these fundamentals. The demand for Java developers remains strong globally, particularly in tech hubs like India and the USA, where companies continually seek skilled professionals to build and maintain their software solutions.

Preparing for a Java interview is crucial for freshers aspiring to secure their first job in this competitive field. The following questions are designed to cover a broad range of topics that are commonly addressed in interviews, including core Java concepts, object-oriented programming principles, exception handling, collections framework, and more. By thoroughly understanding and practicing these questions, candidates can gain confidence and improve their chances of performing well in interviews. This preparation not only helps in answering technical questions but also demonstrates a solid understanding of Java, showcasing the candidate’s readiness to tackle real-world programming challenges.

Join our real-time project-based Java training in Hyderabad for comprehensive guidance on mastering Java and acing your interviews. We offer hands-on training and expert interview preparation to help you succeed in your Java career.

1. What is Java, and what are its key features?

Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a widely-used programming language that is platform-independent, which means that Java programs can run on any device that has the Java Virtual Machine (JVM) installed.

Key features of Java include:

• Platform Independence: Java code can run on any platform without the need for recompilation.
• Object-Oriented: Java follows the principles of Object-Oriented Programming (OOP), such as inheritance, encapsulation, polymorphism, and abstraction.
• Simple and Familiar: Java syntax is similar to C++, making it easier to learn for programmers with a background in C and C++.
• Secure: Java provides a secure environment through its runtime environment, which includes a built-in security manager.
• Multithreaded: Java supports multithreaded programming, which allows concurrent execution of two or more threads.
• Robust: Java is known for its strong memory management, exception handling, and type checking mechanisms.
• High Performance: The Just-In-Time (JIT) compiler improves the performance of Java applications.
• Distributed: Java supports distributed computing, which allows applications to communicate and share resources over a network.

2. Can you explain the difference between JDK, JRE, and JVM?

• JDK (Java Development Kit): JDK is a software development kit that provides the necessary tools and libraries for developing Java applications. It includes the JRE, a compiler (javac), an interpreter/loader (java), an archiver (jar), a documentation generator (javadoc), and other tools needed for Java development.
• JRE (Java Runtime Environment): JRE is a part of the JDK but can also be downloaded separately. It provides the libraries, Java Virtual Machine (JVM), and other components to run Java applications. However, it does not include tools for Java development such as compilers and debuggers.
• JVM (Java Virtual Machine): JVM is an abstract machine that enables your computer to run a Java program. When you run a Java program, the JVM interprets the compiled bytecode and executes it. JVM is platform-dependent, meaning different JVMs are available for different operating systems, but the bytecode is platform-independent.

3. What is an object-oriented programming language, and how does Java support it?

An object-oriented programming (OOP) language is a programming paradigm that uses objects and classes to design and develop applications. OOP languages support the following key principles:

• Encapsulation: Bundling data and methods that operate on the data into a single unit or class.
• Inheritance: Mechanism where one class inherits the properties and behaviors of another class.
• Polymorphism: Ability to take many forms, allowing methods to perform differently based on the object it is acting upon.
• Abstraction: Hiding the complex implementation details and showing only the essential features of the object.

Java supports OOP by allowing developers to create classes and objects, implement inheritance using the extends keyword, achieve polymorphism through method overloading and overriding, and encapsulate data using access modifiers (public, private, protected).

4. What are the main principles of Object-Oriented Programming (OOP)?

The main principles of Object-Oriented Programming (OOP) are:

1. Encapsulation: Encapsulation is the concept of wrapping data (variables) and methods (functions) together into a single unit called a class. It helps in protecting the data from unauthorized access and modification. Encapsulation is achieved using access modifiers such as private, public, and protected.
2. Inheritance: Inheritance allows one class (child or subclass) to inherit the properties and methods of another class (parent or superclass). This promotes code reuse and establishes a relationship between classes. In Java, inheritance is achieved using the extends keyword.
3. Polymorphism: Polymorphism is the ability of an object to take many forms. It allows methods to do different things based on the object it is acting upon. Polymorphism can be achieved through method overloading (compile-time polymorphism) and method overriding (runtime polymorphism).
4. Abstraction: Abstraction is the process of hiding the complex implementation details and showing only the essential features of an object. It helps in reducing complexity and increasing efficiency. Abstraction is achieved using abstract classes and interfaces in Java.

5. What is the difference between ‘==’ and ‘equals()’ in Java?

In Java, == and equals() are used for comparison, but they serve different purposes:

• == Operator: The == operator is used to compare primitive data types (e.g., int, char, boolean) and to compare the references of objects. When used with objects, == checks if the two references point to the same memory location.
  For example:String str1 = new String("Hello"); String str2 = new String("Hello"); System.out.println(str1 == str2); // false, because str1 and str2 are different objects in memory.
• equals() Method: The equals() method is used to compare the contents of two objects. By default, the equals() method in the Object class behaves like the == operator, but it can be overridden to provide meaningful comparison for objects.
  For example:String str1 = new String("Hello"); String str2 = new String("Hello"); System.out.println(str1.equals(str2)); // true, because str1 and str2 have the same content.

6. Can you describe the role of the ‘main()’ method in a Java application?

The main() method is the entry point of any Java application. It is the method that is first invoked when a Java program starts. The signature of the main() method must be:

public static void main(String[] args)

• public: The main() method must be public so that it is accessible to the JVM.
• static: The main() method must be static so that the JVM can invoke it without instantiating the class.
• void: The main() method must return void as it does not return any value.
• String[] args: The main() method accepts a single argument: an array of String objects. This array can be used to pass command-line arguments to the program.

7. What is inheritance in Java, and why is it important?

Inheritance is one of the fundamental principles of Object-Oriented Programming (OOP) that allows a class to inherit the properties (fields) and methods of another class. Inheritance promotes code reuse, improves code organization, and establishes a hierarchical relationship between classes. In Java, inheritance is implemented using the extends keyword. For example:

class Animal {
    void eat() {
        System.out.println("This animal eats.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // Inherited method
        dog.bark(); // Dog-specific method
    }
}

In this example, the Dog class inherits the eat() method from the Animal class and also defines its own bark() method.

8. What are exceptions in Java, and how are they handled?

Exceptions are events that occur during the execution of a program that disrupt the normal flow of instructions. In Java, exceptions are objects that represent these events. Exception handling is a mechanism to handle runtime errors, allowing the program to continue its normal execution.

Exceptions in Java are categorized into two types:

• Checked Exceptions: These are exceptions that are checked at compile-time. They must be either caught or declared in the method using the throws keyword. Examples include IOException, SQLException.
• Unchecked Exceptions: These are exceptions that occur at runtime and are not checked at compile-time. They include RuntimeException and its subclasses, such as NullPointerException, ArrayIndexOutOfBoundsException.

Exception handling in Java is achieved using try, catch, finally, and throw keywords:

try {
    // Code that might throw an exception
} catch (ExceptionType e) {
    // Code to handle the exception
} finally {
    // Code that will always execute, regardless of an exception
}

9. Can you explain the purpose and usage of the ‘final’ keyword in Java?

The final keyword in Java is used to define constants, prevent inheritance, and prevent method overriding. It can be applied to variables, methods, and classes.

• Final Variable: When a variable is declared as final, its value cannot be changed once initialized. This makes it a constant.final int MAX_VALUE = 100;
• Final Method: When a method is declared as final, it cannot be overridden by subclasses. This ensures that the implementation of the method remains unchanged.
  class Parent {
final void show() {
System.out.println("This is a final method.");
}
}
• Final Class: When a class is declared as final, it cannot be subclassed. This is used to prevent inheritance and ensure that the class’s implementation remains unchanged.
  final class FinalClass {
// Class code
}

10. What is the difference between an ArrayList and a LinkedList in Java?

ArrayList and LinkedList are two commonly used implementations of the List interface in Java, but they have different performance characteristics and use cases.

• ArrayList:
  • Internal Structure: ArrayList is backed by a dynamic array.
  • Access Time: It provides constant-time positional access to elements (O(1)).
  • Insertion/Deletion: Insertion and deletion of elements can be slow (O(n)) if they require shifting elements.
  • Memory: ArrayList requires less memory overhead compared to LinkedList due to its array-based structure.
• LinkedList:
  • Internal Structure: LinkedList is backed by a doubly linked list.
  • Access Time: It provides linear-time positional access to elements (O(n)).
  • Insertion/Deletion: Insertion and deletion of elements are faster (O(1)) if the position is known, as it does not require shifting elements.
  • Memory: LinkedList requires more memory overhead due to the storage of node pointers (references to previous and next nodes).

Choosing between ArrayList and LinkedList depends on the specific use case and the type of operations required.

Java Programs for Freshers

1. Write a Java program to print “Hello, World!” to the console.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

2. Write a Java program to check if a given number is even or odd.

import java.util.Scanner;

public class EvenOdd {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a number: ");
        int number = scanner.nextInt();
        if (number % 2 == 0) {
            System.out.println(number + " is even.");
        } else {
            System.out.println(number + " is odd.");
        }
    }
}

3. Write a Java program to find the factorial of a given number.

import java.util.Scanner;

public class Factorial {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a number: ");
        int number = scanner.nextInt();
        int factorial = 1;
        for (int i = 1; i <= number; i++) {
            factorial *= i;
        }
        System.out.println("Factorial of " + number + " is " + factorial);
    }
}

4. Write a Java program to reverse a string.

import java.util.Scanner;

public class ReverseString {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a string: ");
        String input = scanner.nextLine();
        String reversed = new StringBuilder(input).reverse().toString();
        System.out.println("Reversed string: " + reversed);
    }
}

5. Write a Java program to check if a given string is a palindrome.

import java.util.Scanner;

public class Palindrome {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a string: ");
        String input = scanner.nextLine();
        String reversed = new StringBuilder(input).reverse().toString();
        if (input.equals(reversed)) {
            System.out.println(input + " is a palindrome.");
        } else {
            System.out.println(input + " is not a palindrome.");
        }
    }
}

Beginner Java Questions

• What is JVM (Java Virtual Machine)?
• What is JIT (Just-in-Time) Compilation?
• What is Object Oriented Programming?
• What’s a Class?
• What’s an Object?
• What’s the relation between Classes and Objects?
• What are different properties provided by Object-oriented systems?
• How do you implement inheritance in Java?
• How can we implement polymorphism in Java?
• What’s an interface and how will you go about implementing an
• interface?
• What is an Abstract class?
• What are Abstract methods?
• What’s the difference between “Abstract” classes and “Interfaces”?
• What’s difference between Static and Non-Static fields of a class?
• What are inner classes and what’s the practical implementation of
• inner classes?
• What are packages?
• What is a constructor in class?
• Can constructors be parameterized?
• Can you explain transient and volatile modifiers?
• What is the use if “instanceof ” keyword?
• What are Native methods in Java?
• Explain in depth Garbage collector?
• How does the garbage collector determine that the object has to be
• marked for deletion?
• Can you explain “finalize()” method?
• How can we force the garbage collector to run?
• What’s the main difference between “Switch” and “If ” comparison?
• What’s the use of JAVAP tool?
• What are applets?
• In which package is the applet class located?
• What are native interfaces in Java?
• what are Class loader’s?
• what is Bootstrap, Extension and System Class loader?
• Can you explain the flow between bootstrap, extension and system class
• loader?
• Can you explain how can you practically do dynamic loading?
• How can you copy one array in to a different array?
• Can you explain the core collection interfaces?
• Can you explain in brief the collection classes which implement the
• collection interfaces?
• What’s the difference between standard JAVA array and ArrayList class?
• What’s the use of “ensureCapacity” in ArrayList class?
• How can we obtain an array from an ArrayList class?
• What is “LinkedList” class for?
• Can you explain HashSet class in collections?
• what is LinkedHashSet class?
• what is a TreeSet class?
• what’s the use of Comparator Interface?
• How can we access elements of a collection?
• What is Map and SortedMap Interface?
• Have you used any collection algorithm?
• Why do we use collections when we had traditional ways for collection?
• Can you name the legacy classes and interface for collections?
• What is Enumeration Interface?
• what’s the main difference between ArrayList / HashMap and Vector /
• Hashtable?
• Are String object Immutable, Can you explain the concept?
• what is a StringBuffer class and how does it differs from String
• class?
• what is the difference between StringBuilder and StringBuffer class?
• What is Pass by Value and Pass by reference? How does JAVA handle the
• same?
• What are access modifiers?
• what is Assertion?
• Can you explain the fundamentals of deep and shallow Cloning?
• How do we implement Shallow cloning?
• How do we implement deep cloning?
• What’s the impact of private constructor?
• What are the situations you will need a constructor to be private?
• Can you explain final modifier?
• What are static Initializers?
• If we have multiple static initializer blocks how is the sequence
• handled?
• Define casting? What are the different types of Casting?
• Can you explain Widening conversion and Narrowing conversion?
• Can we assign parent object to child objects?
• Define exceptions?
• Can you explain in short how JAVA exception handling works?
• Can you explain different exception types?
• Can you explain checked and unchecked exceptions?
• Can we create our own exception class?
• What are chained exceptions?
• What is serialization?
• How do we implement serialization actually?
• What’s the use of Externalizable Interface?