Unit1 - Subjective Questions

Java is a widely used programming language due to the following key features:

• Simple: Java eliminates complex features of C++ like pointers, operator overloading, and multiple inheritance, making it easier to learn.
• Object-Oriented: Java is purely object-oriented (almost), meaning everything is modeled as an object with data and behavior.
• Platform Independent: Java follows the WORA (Write Once, Run Anywhere) philosophy. Compiled Java code (bytecode) can run on any machine that has a JVM.
• Secure: Java runs inside a virtual machine sandbox and lacks explicit pointers, reducing security risks like buffer overflows.
• Robust: Java emphasizes early error checking, has strong memory management, and automatic garbage collection.
• Multi-threaded: It supports concurrent execution of two or more parts of a program for maximum CPU utilization.
• Distributed: Java is designed for the distributed environment of the internet, supporting protocols like TCP/IP and HTTP.

1. JVM (Java Virtual Machine):
It is an abstract machine that provides a runtime environment in which Java bytecode can be executed. It performs three main tasks: loading code, verifying code, and executing code.

2. JRE (Java Runtime Environment):
It is a set of software tools which are used for developing Java applications. It acts as the implementation of the JVM. It physically exists. It contains a set of libraries + other files that the JVM uses at runtime.

3. JDK (Java Development Kit):
It is a software development environment used to develop Java applications and applets. It physically exists. It contains JRE + development tools (javac, java, javadoc, etc.).

Relationship Equation:

Every word in the main method signature has a specific meaning:

• public: It is an access modifier. It dictates that the method is accessible everywhere. The JVM needs to call this method from outside the class, so it must be public.
• static: It is a keyword. It allows the main method to be called without creating an instance (object) of the class. Since the JVM starts the program, no object exists yet, so the entry point must be static.
• void: It is the return type. The main method does not return any value to the JVM.
• main: It is the name of the method. The JVM looks for this specific name as the starting point of the program.
• String args[]: It is the parameter passed to the main method. It accepts command-line arguments as an array of String objects.

Type conversion is the process of converting one data type into another. In Java, it is classified into two types:

1. Widening Casting (Implicit):
It happens automatically when passing a smaller size type to a larger size type.

• Order:
• Example:
  java
  int myInt = 9;
  double myDouble = myInt; // Automatic casting: 9.0

2. Narrowing Casting (Explicit):
It must be done manually by placing the type in parentheses in front of the value. It is required when converting a larger type to a smaller size type, as data loss may occur.

• Example:
  java
  double myDouble = 9.78;
  int myInt = (int) myDouble; // Manual casting: 9 (fractional part lost)

Java defines 8 primitive data types used to store simple values:

Identifiers are names given to various program elements such as variables, methods, classes, and packages.

Rules for Valid Identifiers:

1. Allowed Characters: Can contain letters (A-Z, a-z), digits (0-9), underscores (_), and dollar signs ($).
2. Start: Must start with a letter, $, or _. It cannot start with a digit.
3. Keywords: Java reserved keywords (e.g., class, void, int) cannot be used as identifiers.
4. Case Sensitivity: Identifiers are case-sensitive (myVar and myvar are different).
5. No Spaces: Spaces are not allowed.

Examples:

• Valid: _value, $salary, student1, calculateSum
• Invalid: 123name (starts with digit), class (keyword), my var (contains space)

Bit-wise operators perform operations on individual bits of integer data types. Assuming () and ():

1. Bitwise AND (&): Returns 1 if both bits are 1.
   • (Decimal 1)
2. Bitwise OR (|): Returns 1 if at least one bit is 1.
   • (Decimal 7)
3. Bitwise XOR (^): Returns 1 if bits are different.
   • (Decimal 6)
4. Bitwise Complement (~): Inverts all bits.
   • (Decimal -6)
5. Left Shift (<<): Shifts bits to the left, filling with 0.
   • (Decimal 10)
6. Right Shift (>>): Shifts bits to the right, preserving sign.
   • (Decimal 2)

The static keyword in Java is used for memory management mainly. It applies to variables, methods, blocks, and nested classes. It indicates that the member belongs to the class rather than a specific instance of the class.

1. Static Variables (Class Variables):

• Declared with the static keyword.
• Only one copy of the variable is created in memory, regardless of how many objects are created.
• Shared among all objects.
• Example: static int count = 0; (Used for counters).

2. Static Methods:

• Can be called without creating an object of the class.
• Can only access static data members and change them.
• Cannot use this or super keywords.
• Example: Math.sqrt() or public static void main(...).

Access modifiers determine the scope (visibility) of a class, constructor, variable, method, or data member. Java provides four types:

• private: Most restrictive. Accessible only within the class.
• default: Accessible only within the same package.
• protected: Accessible within the package and outside the package strictly through inheritance (child classes).
• public: Accessible from anywhere.

Syntax:
java
switch(expression) {
case value1:
// code block
break;
case value2:
// code block
break;
default:
// code block
}

Working:

1. The expression is evaluated once.
2. The value is compared with the values of each case.
3. If a match is found, the associated block of code is executed.

Role of break:

• When Java reaches a break keyword, it breaks out of the switch block.
• It stops the execution of more code and case testing inside the block.
• Without break, fall-through occurs, meaning the program continues to execute the next case statements even if the case value doesn't match, until a break or end of switch is reached.

Wrapper Classes provide a way to use primitive data types (int, boolean, etc.) as Objects. This is necessary because Java Collection frameworks work with Objects, not primitives.

Examples:

• int Integer
• char Character

Autoboxing:
The automatic conversion that the Java compiler makes between the primitive types and their corresponding object wrapper classes.

• Example: Integer a = 5; (Converting int 5 to Integer object automatically).

Unboxing:
The reverse process where the Java compiler automatically converts an Object of a wrapper class to its corresponding primitive type.

• Example: Integer a = new Integer(5); int b = a; (Converting Integer object to int).

The Ternary Operator (also known as the conditional operator) is the only operator in Java that takes three operands. It is used as a shorthand for if-else statements.

Syntax:

Example:
java
int a = 10, b = 20;
int max = (a > b) ? a : b;
// If a > b, max = a, otherwise max = b

Difference from if-else:

• Conciseness: Ternary is a one-liner, whereas if-else takes multiple lines.
• Return Value: The ternary operator returns a value that must be used (assigned or printed), whereas if-else is a control flow statement that doesn't return a value but executes blocks of code.

Command-Line Arguments are arguments passed to a program at the time of running it. These arguments are stored as strings in the String args[] array passed to the main() method.

Java Program:
java
public class CommandLineExample {
public static void main(String[] args) {
System.out.println("Arguments passed: " + args.length);

    // Loop through the arguments
    for (int i = 0; i < args.length; i++) {
        System.out.println("Arg " + i + ": " + args[i]);
    }
}

}

Execution:
java CommandLineExample Hello World 123

Output:
Arg 0: Hello
Arg 1: World
Arg 2: 123

Operator Precedence: Determines the order in which operators are evaluated. Operators with higher precedence are evaluated first.
Associativity: Determines the order in which operators of the same precedence are evaluated (usually Left-to-Right, but Assignment is Right-to-Left).

Calculation:
Expression:

1. Precedence: * and / have higher precedence than +. They are equal in precedence.
2. Associativity: * and / are evaluated Left-to-Right.
3. First, .
   • Expression becomes:
4. Next, (Integer division).
   • Expression becomes:
5. Finally, .

Result:

The primary difference lies in how they evaluate the second operand.

Short-Circuit Operators (&&, ||):

• && (Logical AND): If the first condition is false, the result is known to be false. The second condition is not evaluated (short-circuited).
• || (Logical OR): If the first condition is true, the result is known to be true. The second condition is not evaluated.
• Usage: More efficient, commonly used in boolean logic (if statements).

Standard/Bitwise Operators (&, |) used as Logical:

• &: Both conditions are always evaluated, even if the first is false.
• |: Both conditions are always evaluated, even if the first is true.
• Usage: Used when side effects in the second condition are required (e.g., (x > 0) & (y++ > 5) ensures y is incremented).

Java Bytecode is the instruction set for the Java Virtual Machine (JVM). When a Java program (.java) is compiled by the javac compiler, it is translated into bytecode (.class file) rather than machine code specific to the computer's processor.

Contribution to Platform Independence:

1. Bytecode is machine-neutral. It doesn't contain instructions for an Intel, ARM, or AMD processor specifically.
2. Any device with a JVM installed can interpret or compile (via JIT) this bytecode into the native machine code of that specific device.
3. This allows the developer to compile the code once on Windows, for example, and run the resulting .class file on Linux or macOS without recompilation. This enables the "Write Once, Run Anywhere" feature.

java
// Class Declaration
class Student {
// Fields (Instance Variables)
int id;
String name;

// Method to insert records
void insertRecord(int i, String n) {
    id = i;
    name = n;
}

// Method to display information
void display() {
    System.out.println(id + " " + name);
}

}

// Main Class
public class TestStudent {
public static void main(String args[]) {
// Object Creation (using 'new' keyword)
Student s1 = new Student();

    // Accessing methods
    s1.insertRecord(101, "Alice");
    s1.display();
}

}

This illustrates a class Student with data members (id, name), member functions (insertRecord, display), and the instantiation of the class in the main method.

1. Local Variables:

• Declaration: Inside a method, constructor, or block.
• Scope: Only within the method/block where declared.
• Lifetime: Created when the block is entered, destroyed when the block is exited. No default value (must be initialized).

2. Instance Variables (Non-Static Fields):

• Declaration: Inside a class but outside methods.
• Scope: Throughout the class (except in static context without object ref).
• Lifetime: Created when an object is created (new). Destroyed when the object is garbage collected. Has default values (e.g., 0, null).

3. Static Variables (Class Variables):

• Declaration: Inside a class with the static keyword.
• Scope: Throughout the class.
• Lifetime: Created when the class is loaded by the JVM. Destroyed when the program stops or class is unloaded. Shared across all instances.

The JIT (Just-In-Time) compiler is a component of the JRE (specifically part of the JVM).

1. Interpretation vs. Compilation: Standard interpretation of bytecode is slow because the JVM interprets one instruction at a time.
2. JIT Action: The JIT compiler interacts with the JVM at runtime and compiles sequences of bytecode into native machine code (hardware-specific code) "just in time" for execution.
3. Optimization: It identifies "hotspots" (code that runs frequently) and compiles them into native code. Subsequent calls to that method use the compiled native code directly, skipping the slow interpretation process.
4. Result: This hybrid approach (Interpretation + JIT Compilation) significantly boosts execution speed closer to that of compiled languages like C++.

java
public class LargestNumber {
public static void main(String[] args) {
int n1 = 10, n2 = 25, n3 = 15;

    if (n1 >= n2) {
        if (n1 >= n3) {
            System.out.println(n1 + " is the largest number.");
        } else {
            System.out.println(n3 + " is the largest number.");
        }
    } else {
        if (n2 >= n3) {
            System.out.println(n2 + " is the largest number.");
        } else {
            System.out.println(n3 + " is the largest number.");
        }
    }
}

}

Logic: The outer if checks if n1 is greater than n2. If true, the inner if compares n1 with n3. If the outer if is false (n2 is greater), the inner else block compares n2 with n3.