Java Interview Questions and Answers
Java Core Concepts: Environment, Memory, and OOP
### Java Development Environment
* **JDK** (Java Development Kit): Contains both compiler and execution path. It is for developers
to compile and rectify Java code.
* **JRE** (Java Runtime Environment): Contains only the execution path. It is for customers to run
compiled Java code. JRE is installed automatically when JDK is installed.
* **JVM** (Java Virtual Machine): A virtual machine created on the operating system (Windows,
Linux, Mac) when Java software is installed. It is responsible for executing Java bytecode (class
files).
### `public static void main` Method
This is the main function and the calling point for Java programs.
* **public**: Provides direct access to the JVM.
* **static**: Allows direct execution without the need for object creation.
* **void**: Indicates that the function will not return any value.
* **main**: The primary function from which the program execution begins.
* `String[] args`: Allows passing any number of arguments to the main method.
### Platform Independence
Java is a **platform-independent** language because:
* Java code is compiled into **bytecode** (class files).
* This bytecode can run on any system that has a JVM, regardless of the underlying operating
system.
* Bytecode can be copied from one system to another and executed.
### Object-Oriented Programming (OOP) in Java
Java is **not considered a pure object-oriented language**.
* It does not support certain OOP features like operator overloading and multiple inheritance.
* However, when compared to languages like C++, Java is considered object-oriented.
### Memory Allocation: Heap vs. Stack
* **Heap memory**: Where objects are created.
* **Stack memory**: Where variables are initialized.
Variables, Constants, Control Flow, and Class Loading
### Variables
Variables are used to interact with methods and store data in memory.
### Types of Variables
Page 1 of 5 Generated by SnapLearn
* **Local Variables**: Declared inside methods.
* **Instance Variables**: Declared within a class, associated with objects.
* **Class Variables** (Static Members): Associated with the class itself.
### Constants
* In Java, constants are declared using the **`final` keyword**.
* The `final` keyword imposes restrictions.
* Java does not implement a `const` keyword, unlike C++.
### Control Flow
* **`equals()` method**: Used for **content comparison**.
* **`==` operator**: Used for **address comparison**.
* **Pointers**: Pointers are not used in Java; they are implemented in C++.
### Class Loading
* The **JIT (Just-In-Time) compiler** compiles bytecode into native code.
* This compilation is done to achieve faster performance.
Language Comparisons, Keywords, and Data Types
### The `final` Keyword
The **`final` keyword** is used to declare classes, methods, variables, and constants.
* If a **class** is declared `final`, it **cannot be inherited**.
* If a **method** is declared `final`, it **cannot be overridden**.
* If a **variable** is declared `final`, its **value cannot be changed**.
### `break` vs. `continue` Statements
Both `break` and `continue` are **transfer statements** used within loops and conditional
statements in Java.
* **`break`**: Terminates the loop entirely when encountered. Execution continues with the
statement immediately following the loop.
* Example: In a loop from 1 to 10, if `break` is used at 5, the output would be 1, 2, 3, 4.
* **`continue`**: Skips the current iteration of the loop and proceeds to the next iteration. The code
after the `continue` statement in the current iteration is not executed.
* Example: In a loop from 1 to 10, if `continue` is used at 5, the output would be 1, 2, 3, 4, 6, 7, 8,
9, 10 (the value 5 is skipped).
### Class Loaders
**Class loaders** are a part of the **Java Runtime Environment (JRE)**. They are responsible for
loading `.class` files into the Java Virtual Machine (JVM).
There are three main types of class loaders:
* **Bootstrap Class Loader**
* **Extension Class Loader**
Page 2 of 5 Generated by SnapLearn
* **System Class Loader**
The `main` method of a Java application is typically loaded by the **System Class Loader**.
### Method Overloading vs. Method Overriding
Both **Method Overloading** and **Method Overriding** are concepts related to **Polymorphism**
in Java.
* **Method Overloading**:
* An example of **Compile-time Polymorphism**.
* Occurs **within the same class**.
* Methods have the **same name** but **different parameters** (either in number or type).
* **Method Overriding**:
* An example of **Runtime Polymorphism**.
* Occurs in **different classes** that have a parent-child (inheritance) relationship.
* Methods have the **same name** and **same parameters** as a method in the parent class.
### C++ vs. Java: Multiple Inheritance
One key difference between C++ and Java is their support for multiple inheritance:
* **C++ supports multiple inheritance**.
* **Java does not support multiple inheritance** directly through classes.
Exception Handling, Unicode, and Method Overloading
### Exception Handling
**Exception handling** in Java involves managing runtime errors to maintain program flow. Key
components include:
* **try**: A block of code where exceptions might occur.
* **catch**: A block that handles a specific type of exception thrown by the `try` block.
* **finally**: A block of code that is guaranteed to execute, regardless of whether an exception
occurred or was caught. It is typically used for cleanup operations.
Main Method, Bytecode, Loops, and Access Modifiers
Conclusion and Unspecified Content
### Java Data Types
Java categorizes data types into two main groups:
* **Integer types**: Includes `byte`, `short`, `int`, and `long`.
* **Floating-point types**: Includes `float` and `double`. By default, floating-point literals are
treated as `double`.
### `main` Method Overloading and Overriding
Page 3 of 5 Generated by SnapLearn
* The `main` method (`public static void main(String[] args)`) can be **overloaded** by providing
different arguments.
* **Static methods cannot be overridden** because they are not part of runtime polymorphism.
### Virtual Functions
* In Java, methods are considered virtual by default, unlike C++ where they are explicitly declared.
### Type Casting
* **Implicit type casting** (widening conversion) from `double` to `int` is not possible.
* **Explicit type casting** (narrowing conversion) from `double` to `int` is possible.
### Assignment vs. Initialization
* **Assignment**: Giving a value to a variable that has already been created.
* **Initialization**: Assigning a value to a variable at the time of its creation.
### Unicode System
* **Unicode** is a universal coding system, similar to ASCII.
* It uses a hexadecimal format for character codes.
* Each character occupies 2 bytes (16 bits), supporting 65,536 characters.
### Role of the `main` Method
* The `main` method provides an executable environment for user-defined and pre-defined
methods.
* Before JDK 1.7, Java programs could execute without a `main` method.
* From JDK 1.7 onwards, the `main` method is **compulsory** for program execution.
### Bytecode
* **Bytecode** is generated by the Java compiler (`javac`) and stored in `.class` files.
* It enables Java programs to run on any system, facilitating platform independence.
### Loops in Java
Java supports four types of loops:
* `for` loop
* `while` loop
* `do-while` loop
* `for-each` loop: Primarily used with arrays and collections.
### Access Modifiers in Java
Java has four types of access modifiers:
* **`public`**: Accessible from anywhere (across the board).
* **`private`**: Accessible only within the class where it is declared.
* **`protected`**: Accessible within the declaring class, its package, and by child classes through
inheritance. Its accessibility is restricted beyond the child class.
* **`default` (no keyword)**: Accessible only within the same package.
### `final` Keyword
Page 4 of 5 Generated by SnapLearn
* It is possible to declare variables, methods, and classes as `final` in Java.
### Arrays in Java
* When declaring an array, specifying its **size is necessary**; otherwise, it results in an error.
* Arrays can be multidimensional (e.g., having multiple columns).
Page 5 of 5 Generated by SnapLearn