Java Introduc on

1. What are the key differences between JDK, JRE, and JVM?

1. Java Development Kit (JDK):

<Purpose/Applica on/> This is a collec on of tools that help in developing applica ons in Java.

Components It contains the JRE, compiler (java), class libraries, and tools for debugging as well as
documenta on.

Usage Developers who need to write and compile Java code require this.

2. Java Run me Environment (JRE):

Purpose It is used to provide the run me environment wherein a Java applica on can be run.

Components It consists of the JVM, along with core libraries and other elements essen al to operate
a Java program.

Usage: For users who want to execute Java applica ons without necessarily developing them.

3. JVM (Java Virtual Machine):

It serves as the engine that executes the Java bytecode while crea ng an abstrac on between the
applica on, in this case, Java, and the hardware. It is responsible for conver ng bytecode into
machine code and responsible for memory management.

Usage: Integrated with both JRE and JDK; it provides the independence of a pla orm through the
execu on of applica ons running on any system equipped with a JVM.

So, the JDK is for development, the JRE for the applica on to run, and JVM is the back driver for
execu ng Java code.

2. How does Java differ from C and C++?

Java, C, and C++ are programming languages that have a world of differences in their designing,
func onality, and usage:

1. **Memory Management**:

- **Java**: This language has automa c garbage collec on which inherently lowers the chances of
memory leaks.
 - **C**: Memory management is manual through `malloc` and `free` where a developer has to be
par cular about memory alloca on and dealloca on explicitly.

- **C++**: Similar to C but with the addi on of constructors and destructors, which takes away the
memory management.

2. **Object Oriented Programming**:

- **Java**: Purely object-oriented, where everything is part of a class, inherits, encapsulates, and
uses polymorphism.

- **C**: Procedural language and has no element of object-oriented programming whatsoever.

- **C++**: This language supports both procedural and object-oriented programming, giving it more
flexibility in design.

3. **Pla orm Independence**:

- **Java**: This compiled bytecode runs on the Java Virtual Machine (JVM). Hence, this is a high-
level pla orm independent.

- **C**: This is compiled directly to produce the machine code for the specific pla orm. Therefore,
its programs remain dependent on the specific pla orm.

- **C++**: Same like C, it also compiles directly to pla orm-specific machine code.

4. **Syntax and Complexity**:

- **Java**: Simple syntax, no pointers, reduced complexity, fresh minds find it easy.

- **C**: Pointers: accessing low-level memory through pointers allows powerful but also complex
control.

- **C++**: Increased complexity with operator overloading, templates, and mul ple inheritance.

5. **Standard Libraries** :

- **Java**: Standard libraries, the Java API covers vast func onality, from network stuff to GUI and
data structures.

- **C**: Standard libraries for basic func ons that support input/output, string manipula on etc.

- **C++**: Gives a powerful and useful Standard Template Library, consis ng of general-purpose
data structures and algorithms.

6. **Use Cases**:

- **Java**: Widely used in web applica ons, mobile applica ons (Android), and enterprise-level
solu ons
- **C**: For system programming, embedded systems, performance-cri cal applica ons

- **C++**: Game development, high-performance applica ons, and so ware that requires complex
data structures.

Summary. Java is a portable, easy to use type of language; C is all about performance and low-level
programming; C++ takes an area of features from both but with greater complexity.

3. Explain the structure of a simple Java “Hello World” program.

Simple Java "Hello World" program and several key components structured in a specific way.
Here's an outline of the structure, along with code:

Structure
Class Declara on: All Java programs must be in a class. The class name should have the same
name as the file.
Main Method: The entry point to any Java applica on is the main method and has a specific
signature.
Print Statement: The program uses a print statement, to print text to the console.
Running
Save this file as HelloWorld.java would be the first step.
Compile using javac HelloWorld.java.
Run using: java HelloWorld.
4. What are the different types of variables in Java?

Variables in Java can be classified into several categories based on scope, life me, and data
types. Here are some of the key categories:

### By Scope

#### Instance Variables:

Declared within a class but outside of any method. Each instance (object) of this class has its
own copy of these variables. Accessible from the instance methods and constructor.

Sta c Variables:
It is declared inside a class using the `sta c` keyword.
It is shared among all instances of class so there is only one copy.
Direct access to a class is possible.

- **Local Variables**:
Declared inside a method, constructor, or block.
Accessible only within the method or block.
They must be ini alized before they are used because they do not have a default value.

### 2. **Based on Data Type

- Primi ve Data Types:

- int: It is used for represen ng integers, like `int a = 5;`.
- float: It is used for represen ng floa ng-point numbers, like `float b = 5.5f;`.
- double: It represents double-precision floa ng-point numbers, like `double c = 5.5;`.
- **char**: A single 16-bit Unicode character, such as `char d = 'A';`.
- **boolean**: True or false values, such as `boolean e = true;`.

- **Reference Data Types**:

- Refers to objects and arrays.
- Classes, interfaces, and arrays are examples of these kinds of data types, such as `String
name = "Alice";`.

### Summary

The main types of Java variables are the following:

- **Instance Variables**: These are specific to an object.
- **Sta c Variables**: These are common to all instances of a class.
- **Local Variables**: These are scoped to a method or block.
- **Primi ve Data Types**: Int is like an `int`, float is like a `float`, char is like a `char`, and
boolean is like a `boolean`.
- **Reference Data Types**: Used for objects and arrays.

All these types are very important to the proper management of memory and scope in Java
programming.
5. Describe the basic Java data types and their default values.

Java has several basic (primi ve) data types, each of which is of a specific size and has a
default value. Here's the list of all the above data types along with their default values:

1. byte
Size: 8 bits (1 byte)
Default Value: 0
Descrip on: These are used to represent integer values within the range of -128 to 127.
2. short
Size: 16 bits (2 bytes)
Default Value: 0
Descrip on: This is used to represent integer values within the range of -32,768 to 32,767.
3. int
Size: 32 bits (4 bytes)
Default Value: 0
Descrip on: These represent unsigned integer values varying from 0 to 2^31-1.
4. long
Size: 64 bits (8 bytes)
Default Value: 0L
Descrip on: It denotes integer values varying between -2^63 to 2^63-1. They are generally
used for large integers.
5. float
Size: 32 bits (4 bytes)
Default Value: 0.0f
Descrip on: It represents single precision floa ng point numbers. They are useful for storing
decimal values with limited precision.
6. double
Size: 64 bits (8 bytes)
Default Value: 0.0
Descrip on: Double-precision floa ng point numbers is represented. Compared with float, it
is used for decimal values with more accuracy.
7. char
Size: 16 bits (2 bytes)
Default Value: '\u0000' (null character)
Descrip on: A single 16-bit Unicode character is represented.
8. boolean
Size: Not strictly defined (but typically considered 1 bit)
Default Value: false