☕ I.

Java Interview Questions

Java questions focus heavily on its Object-Oriented Programming (OOP) nature, the JVM, and thread
safety.

1. JVM, JRE, and JDK

Question Answer

* JVM (Java Virtual Machine): The runtime engine that reads and executes
the Java bytecode (the compiled .class files). It makes Java platform-
Explain the independent. * JRE (Java Runtime Environment): The physical installation that
difference between provides the environment to run Java applications. It includes the JVM and the
JDK, JRE, and JVM. Java Class Libraries. * JDK (Java Development Kit): The complete kit used for
developing Java applications. It includes the JRE plus development tools like
the compiler (javac), debugger, and archiver.

Why is Java Java source code is compiled into platform-agnostic bytecode, not machine
"platform- code. This bytecode is then executed by the JVM, which is implemented
independent" specifically for each operating system (Windows, Linux, macOS). This allows
(WORA)? the principle of "Write Once, Run Anywhere" (WORA).

2. OOP and Core Concepts

Question Answer

1. Encapsulation: Binding data (variables) and the code (methods) that

operates on the data into a single unit (a class). This is achieved using access
modifiers (like private) and getter/setter methods. 2. Inheritance: A
mechanism where one class acquires the properties and methods of another
What are the four
class, promoting code reusability. 3. Polymorphism: The ability of an object
pillars of OOP?
to take on many forms. It has two types: Compile-time (Method Overloading)
and Runtime (Method Overriding). 4. Abstraction: Hiding the complex
implementation details and showing only the necessary features to the user.
Achieved using Abstract Classes and Interfaces.

* == compares references (memory addresses). For objects, it checks if two

Difference between reference variables point to the exact same object in memory. * equals()
== and the equals() compares content (values). This method is inherited from the Object class but
method for objects? is typically overridden in classes like String to compare the actual values/data
inside the objects.

* String: Immutable. Any operation that changes the string creates a new
Difference between object. Best for strings that won't change. * StringBuilder: Mutable (can be
String, StringBuilder, changed). Not synchronized/thread-safe. Faster than StringBuffer. *
and StringBuffer? StringBuffer: Mutable. Synchronized/Thread-safe. Slower due to
synchronization overhead. Best for use in multi-threaded environments.

Defining multiple methods in the same class with the same name but with a
What is Method
different number or type of parameters. This is Compile-time (Static)
Overloading?
Polymorphism.
Question Answer

Defining a method in a subclass that has the exact same name, signature
What is Method
(parameters), and return type as a method in its superclass. This is Runtime
Overriding?
(Dynamic) Polymorphism.

🐍 II. Python Interview Questions

Python questions test your knowledge of its dynamic typing, built-in data structures, and unique
language features.

1. Core Data Structures and Features

Question Answer

* List: Mutable (elements can be added, removed, or changed). Defined

using square brackets []. Used for ordered collections that may need to be
Difference between a
modified. * Tuple: Immutable (cannot be changed after creation). Defined
list and a tuple?
using parentheses (). Used for fixed collections and generally faster for
iteration.

* Mutable: Objects whose state can be changed after they are created.
What are mutable and Examples: list, dict, set. * Immutable: Objects whose state cannot be
immutable data types? changed after they are created. Examples: int, float, tuple, str. If you
"change" an immutable object, you are actually creating a new object.

* == compares values (checks if the contents of the objects are equal). * is

Difference between is
compares identity (checks if two variables refer to the exact same object in
and ==?
memory).

A decorator is a design pattern that allows you to modify or enhance a

What is a Python function or a class without explicitly modifying its source code. It is
decorator? syntactic sugar that takes a function as an argument, adds functionality,
and returns the modified function.

A concise, readable, and often faster way to create lists (and

sets/dictionaries) using an existing iterable. They replace verbose for loops
with conditional logic.
What are List
Comprehensions?

Example: squares = [x*x for x in range(10) if x % 2 == 0]

These are special syntax used in function definitions to pass a variable

What are *args and number of arguments: * *args: Used to pass a variable number of non-
**kwargs? keyworded (positional) arguments as a tuple. * **kwargs: Used to pass a
variable number of keyworded arguments as a dictionary.

2. General Python Concepts

Question Answer

The GIL is a mutex (lock) in the CPython implementation that ensures only one
What is the Global
thread executes Python bytecode at a time in a single process. While it
Interpreter Lock
simplifies Python's memory management, it prevents true parallel execution of
(GIL)?
CPU-bound tasks in multi-threaded programs.

Python uses private heap space to store objects and data structures. It uses an
automatic garbage collection mechanism called reference counting to
Explain Python's
deallocate memory for objects when their reference count drops to zero. A
memory
generational garbage collector also runs periodically to collect objects that are
management.
part of reference cycles (where objects still refer to each other but are
unreachable from the rest of the program).

It is a special method, often called the constructor, that is automatically called

What is the when a new instance of a class is created. It is used to initialize the object's
__init__ method? attributes (state). It explicitly takes self as the first argument, which refers to the
newly created instance.

⚖️III. Java vs. Python: Key Differences

Interviewers often ask candidates to contrast the two languages to test their understanding of
fundamental architectural choices.

Feature Java Python

Statically Typed: Type checking occurs Dynamically Typed: Type checking occurs at
Typing at compile time (must declare variable runtime (variable type can change). Offers
type). Errors are caught early. flexibility.

Compiled to bytecode, executed by

Interpreted line-by-line. Slower runtime but
Execution JVM. Generally faster for large-scale,
faster development/prototyping.
CPU-intensive applications.

Verbose, requires semicolons, curly Concise, uses indentation to define code

Code
braces ({ }), and explicit class definitions blocks (no semicolons/braces). Highly
Structure
for everything. readable.

Strong support for true multithreading.

Limited by the GIL, which prevents true
Concurrency Excellent for high-performance
parallel execution of CPU-bound threads.
concurrent systems.

Enterprise-level applications, Android Data Science/AI/ML, Web Development

Primary Use
development, Big Data processing. (Django/Flask), Automation/Scripting.