**1. What is JDK?
**
The Java Development Kit (JDK) is a software development kit used to develop Java applications. It
includes the JRE (Java Runtime Environment), an interpreter/loader (Java), a compiler (javac), an archiver
(jar), a documentation generator (Javadoc), and other tools needed for Java development.
**2. What is JRE?**
The Java Runtime Environment (JRE) is a part of the JDK that provides the libraries, Java Virtual Machine
(JVM), and other components to run applications written in Java. It do
es not contain development tools like compilers or debuggers.
**3. What is JIT compiler?**
The Just-In-Time (JIT) compiler is a component of the JRE that improves the performance of Java
applications by compiling bytecode into native machine code at runtime. This allows the Java program to
run faster than interpreting the bytecode line by line.
**4. What is Adaptive optimizer?**
The Adaptive optimizer is a part of the JVM that enhances the performance of Java applications. It
dynamically analyzes the running code, identifies hotspots, and optimizes them by compiling frequently
executed bytecode into native code, adapting the optimizations based on the runtime behavior.
**5. What is Class Loader?**
A Class Loader in Java is a part of the Java Runtime Environment that dynamically loads Java classes into
the JVM. It is responsible for finding and loading class files at runtime, thus separating the class loading
mechanism from the actual execution of the code.
**6. What is Byte Code Verifier?**
The Byte Code Verifier is a part of the JVM that checks the validity of the bytecode before it is executed.
It ensures that the bytecode adheres to the Java language specifications and does not violate any
security constraints, thus preventing the execution of potentially harmful or illegal code.
**7. What is a Compiler?**
A compiler is a tool that translates source code written in a high-level programming language into
machine code or bytecode that a computer's processor can execute. In the context of Java, the compiler
(javac) converts Java source code into bytecode.
**8. What is an Interpreter?**
An interpreter is a tool that executes instructions written in a programming or scripting language without
converting them into machine code. In Java, the JVM acts as an interpreter by executing the compiled
bytecode.
**9. What is the difference between a Compiler and Interpreter?**
A compiler translates the entire source code of a program into machine code or bytecode before
execution, resulting in faster runtime performance. An interpreter, on the other hand, translates and
executes code line by line at runtime, which can lead to slower performance but offers more flexibility
and easier debugging.
**10. What are the components of JVM?**
The main components of the Java Virtual Machine (JVM) include:
- Class Loader
- Bytecode Verifier
- Interpreter
- Just-In-Time (JIT) Compiler
- Garbage Collector
- Runtime Memory (Heap, Stack, Method Area, etc.)
**11. What is Platform Independent?**
Platform independence means that software can run on any operating system or hardware platform
without modification. Java achieves platform independence through its use of bytecode, which can be
executed on any system equipped with a compatible JVM.
**12. How does Java achieve Platform independence?**
Java achieves platform independence by compiling source code into an intermediate form known as
bytecode. This bytecode is executed by the JVM, which abstracts away the underlying platform details
and provides a consistent execution environment across different platforms.
**13. How to access command line arguments?**
In Java, command line arguments are accessed using the `args` parameter in the `main` method. For
example:
```java
public static void main(String[] args) {
for (String arg : args) {
[Link](arg);
}
}
```
**14. What are the data types in Java and what are their sizes?**
Java has two categories of data types: primitive and reference. The primitive data types and their sizes
are:
- byte: 1 byte
- short: 2 bytes
- int: 4 bytes
- long: 8 bytes
- float: 4 bytes
- double: 8 bytes
- char: 2 bytes
- boolean: 1 bit (though size is JVM dependent)
**15. How do you declare an array in Java?**
An array in Java can be declared as follows:
```java
int[] array;
int[] array = new int[10];
```
**16. How do you find the length of an array in Java?**
The length of an array in Java can be found using the `length` property:
```java
int length = [Link];
```
**17. What is the use of PATH variable?**
The PATH variable specifies a set of directories where executable programs are located. When you type a
command in the terminal, the system searches these directories to find the executable program.
**18. What is the use of CLASSPATH variable?**
The CLASSPATH variable is used by the JVM and Java tools to locate Java class files. It specifies the
directories, JAR files, and ZIP files to search for classes and packages used by Java programs.
**19. How do you assign values for PATH and CLASSPATH Variable?**
Values for PATH and CLASSPATH can be assigned in the terminal or command prompt. For example:
- On Windows:
```cmd
set PATH=C:\path\to\directory;%PATH%
set CLASSPATH=C:\path\to\classes;%CLASSPATH%
```
- On Unix/Linux:
```bash
export PATH=/path/to/directory:$PATH
export CLASSPATH=/path/to/classes:$CLASSPATH
```
**20. What are all the characteristic features of Java Programming language?**
Java has several characteristic features:
- Platform Independence
- Object-Oriented
- Simple and Easy to Learn
- Secure
- Robust and Reliable
- Multithreaded
- High Performance (thanks to JIT Compiler)
- Distributed and Network-Oriented
- Dynamic and Extensible