java full stack – 100% job guarantee program

Core Java 2025 Interview Series-1

Junior Level Questions Level-1
1. Characteristics of Object-Oriented Programming
(OOP) languages:

 Encapsulation: Bundling data (attributes) and methods

(functions) that operate on the data into a single unit,
usually a class.
 Abstraction: Hiding implementation details and showing
only the essential features of an object.
 Inheritance: Allows a new class (subclass) to inherit
properties and behaviors (methods) from an existing class
(superclass).
 Polymorphism: The ability of an object to take many
forms. Specifically, it allows one interface to be used for a
general class of actions.
 Modularity: The code is organized into discrete units
called classes and objects, improving code maintainability
and readability.

2. Access Modifiers in Java:

 public: The member is accessible from anywhere.

 private: The member is only accessible within the same
class.
 protected: The member is accessible within the same
package or subclasses.
 default (package-private): If no access modifier is
specified, the member is accessible only within the same
package.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

3. Overriding vs Overloading:

 Overriding: Changing the behavior of an existing method

in a subclass. It requires the method signature (name,
parameters) to be the same as in the parent class.
 Overloading: Defining multiple methods with the same
name but different parameter lists (different number of
parameters or parameter types) in the same class.

4. Interface vs Abstract Class:

 Interface: It defines a contract for what methods a class

must implement. All methods in an interface are implicitly
abstract (before Java 8), and an interface cannot contain
any method implementation.
 Abstract Class: It is a class that cannot be instantiated
directly. It can have both abstract methods (without
implementation) and concrete methods (with
implementation). An abstract class can also hold instance
variables.

5. Can an Interface extend another Interface?

 Yes, an interface can extend another interface, and it can

extend multiple interfaces (Java supports multiple
inheritance of interfaces). The extending interface will
inherit all the abstract methods of the parent interface(s).

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

6. Meaning of the static keyword in Java:

 The static keyword in Java is used to indicate that a

member (variable, method) belongs to the class rather
than instances of the class. This means the static member
can be accessed without creating an object of the class.

7. Can a static method be overridden in Java?

 No, static methods cannot be overridden. They can be

hidden in subclasses, but overriding applies only to
instance methods.

8. Polymorphism and Inheritance:

 Polymorphism: The ability for different classes to be

treated as instances of the same class through inheritance
or interfaces. It typically refers to method overriding
where a subclass can provide a specific implementation
for a method defined in a superclass.
 Inheritance: A mechanism where one class (subclass)
inherits the fields and methods of another class
(superclass), promoting code reuse.

9. Can a constructor be inherited?

 No, constructors cannot be inherited. However, a subclass

can call a constructor of its superclass using super().

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

10. Objects passed by reference or value in Java?

 In Java, all arguments are passed by value. However, if

you pass an object, you are passing the value of the
reference (memory address) to the object. This means
that the reference to the object is copied, and changes
made to the object affect the original, but if the reference
itself is changed (e.g., pointing to another object), the
original reference is not affected.

11. Difference between == and .equals() on a string:

 ==: Compares memory references (whether two objects

point to the same memory location).
 .equals(): Compares the content (value) of two objects. In
the case of strings, it compares the sequence of
characters.

12. Usage of hashCode() and equals():

 hashCode(): Returns an integer hash code value that

represents the object's memory address or its state. It is
used in hash-based collections like HashMap and HashSet.
 equals(): Determines whether two objects are considered
equal based on their state (not their memory address).

13. Serializable vs Parcelable:

 Serializable: A standard Java interface that allows an

object to be converted into a byte stream and saved or

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

transmitted, so it can be restored later. It is a simple but

slower method.
 Parcelable: A more efficient, Android-specific interface
for serializing objects. It involves manual implementation
and is faster than Serializable.

14. Array vs ArrayList:

 Array: A fixed-size collection that holds elements of the

same type. It has a predefined length and cannot be
resized.
 ArrayList: A dynamic array implementation in Java. It can
grow or shrink in size dynamically, but it has an overhead
because of its flexibility.

15. Difference between Integer and int:

 int: A primitive data type used to represent integer values

(e.g., 5, -12).
 Integer: A wrapper class for the primitive int. It is used
when you need to use an object-oriented approach (e.g.,
in collections like ArrayList).

16. What is a ThreadPool?

 A ThreadPool is a collection of reusable worker threads

used to execute tasks concurrently. It improves
performance by reusing threads, instead of creating new
threads for every task. It is generally more efficient than
creating separate threads for each task because it reduces
thread creation overhead.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

17. Difference between local, instance, and class

variables:

 Local Variable: A variable declared inside a method or

block, and it can only be accessed within that method or
block.
 Instance Variable: A variable declared in a class, but
outside any method. It is specific to each instance of the
class.
 Class Variable: A variable declared as static in a class. It
is shared among all instances of the class and can be
accessed without creating an instance.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

Junior Level Questions Level-2

1. What is Reflection in Java?

 Reflection is a feature in Java that allows the inspection

and modification of classes, methods, fields, and other
metadata during runtime. It enables you to access
information about a class (like its methods, constructors,
and fields) and modify it dynamically. It is commonly used
in frameworks like Spring and Hibernate for operations like
dependency injection, mapping, and more.

2. What is Dependency Injection? Can you name a few

libraries?

 Dependency Injection (DI) is a design pattern where an

object’s dependencies (i.e., objects it needs to function)
are provided externally rather than being created inside
the object. This promotes loose coupling and easier
testing.
 Some popular libraries for Dependency Injection in Java
include:
o Spring Framework
o Google Guice
o Dagger
o CDI (Contexts and Dependency Injection)
 Yes, I've worked with Spring Framework for DI.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

3. What are strong, soft, and weak references in Java?

 Strong Reference: The standard reference type in Java.

An object referenced by a strong reference will not be
garbage collected.
 Soft Reference: Objects with soft references are
collected only when the JVM needs memory. They are
useful for implementing memory-sensitive caches.
 Weak Reference: Objects with weak references are
collected as soon as they are no longer strongly
reachable. They are used to implement data structures
like WeakHashMap.

4. What does the synchronized keyword mean?

 The synchronized keyword in Java is used to ensure that a

method or block of code is accessed by only one thread at
a time. It provides thread safety by allowing only one
thread to execute the synchronized block or method for a
particular object or class.

5. Can you have “memory leaks” in Java?

 Yes, although Java has automatic garbage collection,

memory leaks can still occur if references to unused
objects are not properly released. This can happen when

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

objects are unintentionally kept alive, preventing the

garbage collector from reclaiming memory.

6. Do you need to set references to null in Java/Android?

 Java: It's not mandatory to set references to null, but it

can help in some cases, especially for large objects, to
make sure they are eligible for garbage collection.
However, relying too much on this can lead to
unnecessary code complexity.
 Android: It’s recommended to set large objects,
particularly those holding resources like bitmaps or
context references, to null when they're no longer needed
to avoid memory leaks, especially in activities and
fragments.

7. What does it mean to say that a String is immutable?

 A String in Java is immutable, meaning once a String

object is created, its value cannot be changed. Any
operation on a String (e.g., concatenation) creates a new
String object rather than modifying the original one.

8. What are transient and volatile modifiers?

 transient: Used to indicate that a field should not be

serialized. When an object is serialized, transient fields are
ignored.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

 volatile: Used to indicate that a field can be accessed and

modified by multiple threads concurrently. It ensures
visibility of changes made to the variable by one thread to
other threads.

9. What is the finalize() method?

 The finalize() method in Java is invoked by the garbage

collector before an object is garbage collected. It allows an
object to clean up resources (like closing files or releasing
connections) before it’s destroyed. However, its use is
discouraged, and try-with-resources and explicit
resource management are preferred.

10. How does the try { } finally { } work?

 The finally block is always executed, regardless of whether

an exception is thrown in the try block or not. It's typically
used to release resources (like closing streams or
connections) to ensure they are cleaned up properly.

11. What is the difference between instantiation and

initialization of an object?

 Instantiation refers to the process of creating an object

from a class using the new keyword. It allocates memory
for the object.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

 Initialization refers to the process of assigning values to

the object's fields after it has been instantiated. It may be
done via constructors, setter methods, or directly at the
point of creation.

12. When is a static block run?

 A static block is run when the class is first loaded into

memory. It is executed only once, before any instances of
the class are created or static methods are accessed.

13. Why are Generics used in Java?

 Generics in Java allow for type safety at compile-time.

They allow you to write code that can work with different
types while avoiding the need for type casting. For
example, a List<T> can hold objects of any type, and the
compiler ensures that only the specified type can be
added to the list.

14. Can you mention the design patterns you know?

Which of those do you normally use?

 Some common design patterns are:

o Singleton: Ensures a class has only one instance
and provides a global point of access to it.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

o Factory: Creates objects without specifying the

exact class of object that will be created.
o Observer: Defines a one-to-many dependency
between objects so that when one object changes
state, all its dependents are notified.
o Strategy: Defines a family of algorithms,
encapsulates each one, and makes them
interchangeable.
o Decorator: Adds responsibilities to an object
dynamically.
o Adapter: Converts the interface of a class into
another interface that a client expects.
o Facade: Provides a simplified interface to a complex
subsystem.
 I regularly use the Singleton, Factory, and Observer
patterns, especially when working with frameworks like
Spring, which leverages DI and other design patterns.

15. Can you mention some types of testing you know?

 Unit Testing: Testing individual units or components of

the code in isolation.
 Integration Testing: Testing the interaction between
different modules or systems.
 System Testing: Testing the complete system to ensure
it meets the requirements.
 Acceptance Testing: Validating that the system meets
the business requirements and is ready for deployment.

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

 Regression Testing: Ensuring that new changes or

features don't break existing functionality.
 Performance Testing: Testing the system for
performance issues, like response time, scalability, and
load capacity.
 Smoke Testing: A basic test to check if the most crucial
functions of the system work as expected.

Junior Level Questions Level-3

1. How does Integer.parseInt() work?

 The Integer.parseInt() method converts a string

representation of a number (e.g., "123") into its
corresponding integer value. It parses the string and
checks if it's a valid number. If the string is not a valid
number, it throws a NumberFormatException.
 Example: int num = Integer.parseInt("123");

2. What is the “double check locking” problem?

 Double-check locking is a technique often used to

reduce the overhead of acquiring a lock by first testing the
condition without synchronization. However, it can lead to
issues in multi-threaded environments because the

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

memory visibility guarantees in Java are not always met.

This happens because, after checking the condition once,
the thread may proceed without locking, and the result
might be inconsistent across threads. It is commonly used
in singleton design patterns but can be problematic if not
implemented correctly (e.g., not using volatile keyword).

3. What is the difference between StringBuffer and

StringBuilder?

 Both StringBuffer and StringBuilder are classes used to

manipulate strings, but their key difference lies in thread-
safety:
o StringBuffer: Synchronized, which means it's
thread-safe. However, this comes with a performance
overhead.
o StringBuilder: Not synchronized, so it is not thread-
safe but is faster than StringBuffer when used in
single-threaded scenarios.

4. How is a StringBuilder implemented to avoid the

immutable string allocation problem?

 Unlike String (which is immutable), StringBuilder is

mutable. It maintains an internal array of characters, and
when characters are appended or modified, the array is
resized or adjusted in place without creating a new object
every time, unlike String. This allows more efficient string
manipulation.

5. What does Class.forName() do?

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

 The Class.forName() method is used to load a class

dynamically at runtime. It returns the Class object
associated with the class name provided as a string. This
is typically used in cases like JDBC (e.g., loading database
drivers) or Reflection when you don't know the class at
compile time but need to load it at runtime.

Example: Class.forName("com.example.MyClass");

6. What is Autoboxing and Unboxing?

 Autoboxing: The automatic conversion between primitive

types and their corresponding wrapper classes. For
example, an int is automatically converted to an Integer
when needed.
java
Copy
Integer num = 10; // Autoboxing from int to Integer

 Unboxing: The reverse of autoboxing, where an object of

a wrapper class is automatically converted to its
corresponding primitive type.
java
Copy
int num = new Integer(10); // Unboxing from Integer to int

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

7. What’s the difference between an Enumeration and

an Iterator?

 Enumeration: It is an older interface for iterating over

collections, primarily used with legacy classes like Vector
and Hashtable. It has methods like hasMoreElements() and
nextElement().
 Iterator: A more modern interface introduced in the Java
Collections Framework. It is used to iterate over most
collections. It has methods like hasNext(), next(), and
remove(). It also allows you to remove elements during
iteration, which Enumeration does not support.

8. What is the difference between fail-fast and fail-safe

in Java?

 Fail-fast: A collection or iterator that immediately throws

a ConcurrentModificationException if the collection is
modified during iteration (e.g., in the case of ArrayList or
HashMap iterators).
 Fail-safe: A collection or iterator that doesn't throw an
exception if the collection is modified during iteration.
Instead, it operates on a copy of the collection. Examples
include collections in java.util.concurrent (e.g.,
CopyOnWriteArrayList).

9. What is PermGen in Java?

 PermGen (Permanent Generation) was a part of the Java

heap memory in earlier versions (Java 7 and before). It
was used to store metadata like class definitions, method

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

definitions, and static content. Since Java 8, PermGen has

been replaced by Metaspace, which is not part of the
heap and is managed separately by the native memory
system.

10. What is a Java PriorityQueue?

 A PriorityQueue is a collection that stores elements in a

sorted order, where the element with the highest or lowest
priority is always at the front. Elements are ordered based
on their natural ordering or by a custom comparator. It is
often used when you need to process elements in order of
priority (e.g., a scheduling system).

11. Is performance influenced by using the same

number in different types: int, double, and float?

 Yes, the performance can be affected due to the

differences in how each type is stored and processed:
o int: A 32-bit integer is processed faster than double
or float because it uses less memory and is easier for
the processor to handle.
o float: A 32-bit floating-point number, requiring more
processing than an int but less than a double.
o double: A 64-bit floating-point number that requires
more memory and more processing power than int
and float.
 So, using the correct type for the required precision is
essential for optimizing performance.

12. What is the Java Heap?

DILSUKHNAGAR 9705737799 9705287799

 java full stack – 100% job guarantee program

 The heap in Java is a runtime memory area used for

dynamic memory allocation. It is where all class instances
(objects) and arrays are stored. Memory management in
the heap is handled by the garbage collector, which
automatically reclaims memory that is no longer in use.

13. What is a Daemon thread?

 A daemon thread is a thread that runs in the background

and is used for tasks like garbage collection or background
processing. The JVM will exit when all non-daemon threads
have finished, even if daemon threads are still running.
Daemon threads can be created using
Thread.setDaemon(true) before starting the thread.

14. Can a dead thread be restarted?

 No, once a thread has completed its execution (i.e., a

"dead" thread), it cannot be restarted. You would need to
create a new thread and start it again if you want to
perform the same task.

DILSUKHNAGAR 9705737799 9705287799