JAVA PROGRAMMING

Assignment - 1
Program: BTECH (CSE Data Science and Artificial Intelligence (IBM))
5th Semester
Course Code: CSE504-22
Session: 2024-25

CT University, Ludhiana
Submitted in partial fulfilment of the requirement for the award of the
Degree of Bachelors of Data Science and Artificial Intelligence in Computer
Science Engineering along with IBM

SUBMITTED BY: SUBMITTED TO:

NAME: Kondru Jagadish Choudari Er. Shreya
Gandhi

REGISTRATION NO.: 72212619

 SECTION -A
1.What is fall form of JVM in Java?
A: The Java Virtual Machine (JVM) serves as a runtime
environment, enabling Java applications to operate across
various platforms and operating systems.
2. Name one feature of Java that make it platform
independent?
A: A key characteristic of Java that contributes to its platform
independence is the Java Virtual Machine (JVM). The JVM
enables the execution of Java bytecode on any platform
equipped with a compatible JVM, thereby allowing Java
applications to operate across various operating systems
without the need for alterations.
3. What is Byto code in Java?
A: - In Java, bytecode refers to the intermediate code
produced following the compilation of a Java source file
(.java). - This code is low-level and platform-independent,
allowing it to be executed by the Java Virtual Machine (JVM).
- Bytecode is contained within `.class` files and can be
executed on any platform equipped with a compatible JVM,
thereby enhancing Java's platform independence.
 SECTION -B
1. Briefly explain the purpose of JDK?
A: The Java Development Kit (JDK) is a comprehensive
software development environment used for building and
running Java applications. It includes essential tools and
components, such as:
- The Java Development Kit (JDK) serves as a robust software
development environment designed for the creation and
execution of Java applications. It encompasses vital tools and
components, including a compiler, which translates Java
source code into bytecode executable by the Java Virtual
Machine (JVM). - It also incorporates the Java Runtime
Environment (JRE), which supplies the necessary libraries and
JVM for running Java applications, along with a debugger that
assists developers in detecting and resolving code errors. -
Furthermore, the JDK features JavaDoc for generating API
documentation from source code comments and various
additional tools, such as `jar` for application packaging and
`jarsigner` for application security, making it indispensable for
Java application development, testing, and deployment.
The JDK is essential for developing, testing, and deploying
Java applications, making it the primary toolkit for Java
programmers.
2. Disable the difference b/w C++ and Java in terms of oops
and memory management?
A: 1. A concise comparison of C++ and Java regarding Object-
Oriented Programming (OOP) and memory management
reveals distinct characteristics of each language. 2. C++ is
classified as a hybrid language, accommodating both
procedural and object-oriented programming paradigms, and
it permits multiple inheritance, enabling a class to derive
from several base classes. Additionally, C++ employs pointers,
granting direct access to memory, which facilitates manual
memory manipulation and the creation of intricate data
structures such as linked lists and trees. In contrast, Java is
recognized as a purely object-oriented language, treating all
entities, except for primitive types, as objects. While Java
does not allow multiple inheritance directly due to the
complications associated with the "diamond problem," it
utilizes interfaces to provide similar capabilities. Furthermore,
Java eliminates the use of pointers, thereby enhancing
security and simplifying memory access. 3. When it comes to
memory management, C++ requires manual intervention,
placing the onus on developers to allocate and deallocate
memory using the new and delete operators, respectively.
This level of control can optimize performance but also
heightens the risk of errors, such as memory leaks and
dangling pointers. Conversely, Java automates memory
management through an integrated garbage collector, which
systematically identifies and reclaims memory that is no
longer in use. This automation diminishes the chances of
memory leaks and streamlines the development process,
although it may lead to unpredictable performance during
garbage collection cycles. 4. Overall, these distinctions
underscore C++'s superior flexibility and control in both OOP
and memory management, while Java is characterized by its
emphasis on simplicity and safety.
3. Explain the scope variable in Java with example?
A: In Java, the scope of a variable defines where in the
program the variable can be accessed and used. There are
three primary categories of variable scope: local variables,
instance variables, and class variables. Each type has a
distinct scope and lifecycle.
1. Local Variables
 Scope: Local variables are declared inside a method,
constructor, or block. They can only be accessed within
the method or block where they are defined. Once the
method or block completes execution, the local variable
is destroyed.
 Example:
java
Copy code
public class Example {
public void show() {
int x = 10; // Local variable
System.out.println("Value of x: " + x);
}
}
In this example, x is a local variable, and its scope is limited to
the show method.
2. Instance Variables
 Scope: Instance variables are declared within a class but
outside any method, constructor, or block. These
variables are tied to an instance of the class and can be
accessed by all methods, constructors, and blocks within
that class. They exist as long as the instance (object) of
the class exists.
 Example:
java
Copy code
public class Example {
int y = 20; // Instance variable

public void display() {

System.out.println("Value of y: " + y);
}
}
Here, y is an instance variable, and its scope is the entire
Example class. It can be accessed by any method in the class.
3. Class Variables (Static Variables)
 Scope: Class variables, also known as static variables, are
declared with the static keyword inside a class but
 outside any method, constructor, or block. These
variables belong to the class itself rather than any
instance of the class, and they are shared among all
instances of the class. The scope of a class variable is the
entire class.
 Example:
java
Copy code
public class Example {
static int z = 30; // Class variable (static)

public void displayZ() {

System.out.println("Value of z: " + z);
}
}
In this example, z is a class variable, and its scope covers the
entire Example class. It is shared by all instances of the class.

4. Difference b/w variable and constant?

A: In Java, the main difference between a variable and a
constant is their mutability:
Variable:
  Definition: A variable is a named storage location that
can hold a value that may change during the program's
execution.
 Behavior: You can assign a value to a variable and later
modify that value as needed.
 Declaration:
o Syntax: dataType variableName; (e.g., int age;)
o Assignment: variableName = value; (e.g., age = 25;)
Constant:
 Definition: A constant is a named storage location that
holds a value which cannot be changed once it is
assigned.
 Purpose: Constants are useful for representing values
that should remain fixed throughout the program, such
as mathematical constants (e.g., PI) or configuration
values.
 Declaration:
o Syntax: final dataType constantName = value; (e.g.,
final double PI = 3.14159;)
Key Differences:
 Mutability: Variables can have their values changed,
whereas constants cannot be modified after their initial
assignment.
 Declaration: The final keyword is used to declare a
constant, signaling that its value is immutable.
  Usage: Variables are used to store data that might
change during program execution, while constants are
used to store data that should remain unchanged

SECTION -C
1. WAP that demastrate the ux of decision Making and
looping statement Explain each part of the program.
A: I'd be glad to provide a Java program that demonstrates
decision-making and looping statements, along with
explanations:
import java.util.Scanner;
public class DecisionMakingAndLooping {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Decision-making: Prompt the user for input
System.out.print("Enter a number: ");
int number = scanner.nextInt();
// Decision-making: Check if the number is positive,
negative, or zero
if (number > 0) {
System.out.println("The number is positive.");
 } else if (number < 0) {
System.out.println("The number is negative.");
} else {
System.out.println("The number is zero.");
}
// Looping: Calculate the factorial of the number
int factorial = 1;
for (int i = 1; i <= number; i++) {
factorial *= i;
}
// Output the factorial
System.out.println("The factorial of " + number + " is " +
factorial);
// Looping: Print the numbers from 1 to 10
System.out.println("Numbers from 1 to 10:");
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
}
}
Explanation:
1. Import: The java.util.Scanner class is imported for user
input.
2. Main Method: The main method is the entry point of
the program.
3. Scanner Object: A Scanner object named scanner is
created to read user input from the console.
4. Decision-Making:
o The user is prompted to enter a number.
o An if-else statement is used to check the value of
the number:
 If the number is greater than 0, it's positive.
 If the number is less than 0, it's negative.
 Otherwise, it's zero.
5. Looping: Factorial Calculation:
o A for loop iterates from 1 to the entered number.
o In each iteration, the current value of i is multiplied
by the current value of factorial.
o The final value of factorial is the factorial of the
entered number.
6. Output:
o The factorial of the entered number is printed.
7. Looping: Printing Numbers:
o Another for loop iterates from 1 to 10.
 o In each iteration, the current value of i is printed.
Key Points:
 The program demonstrates both decision-making (using
if-else) and looping (using for).
 The Scanner class is used to get user input.
 The for loop is a common choice for iterating a fixed
number of times.
 The program provides clear explanations for each part,
making it easy to understand.
2. Discard the significance of JVH and Java API's in Java
platform independence & portability?
A: I'd be glad to provide a concise and informative response
to the significance of JVMs and Java APIs in Java platform
independence and portability.
The JVM: The Foundation of Platform Independence
The Java Virtual Machine (JVM) is a crucial component of the
Java platform that plays a pivotal role in ensuring platform
independence and portability. Here's a breakdown of its
significance:
 Bytecode Interpreter: The JVM interprets Java bytecode,
the intermediate language generated by the Java
compiler. This bytecode is platform-neutral, meaning it
can be executed on any system with a compatible JVM.
 Abstraction Layer: The JVM provides a layer of
abstraction between the Java code and the underlying
 hardware and operating system. This abstraction allows
Java programs to run seamlessly on different platforms
without requiring modifications.
 Dynamic Linking: The JVM performs dynamic linking,
deferring the resolution of symbolic references until
runtime. This enables greater flexibility and reduces the
need for static linking, which can be platform-
dependent.
 Memory Management: The JVM incorporates automatic
memory management through garbage collection,
relieving developers from the burden of manual memory
allocation and deallocation. This simplifies programming
and reduces the risk of memory-related errors.
Java APIs: Building Blocks of Portability
Java APIs (Application Programming Interfaces) provide a rich
set of pre-defined classes and methods that developers can
use to create various applications. These APIs are essential
for achieving platform independence and portability:
 Cross-Platform Functionality: Java APIs offer a wide
range of functionalities, from basic I/O operations to
complex network communication and GUI development.
These APIs are implemented in a platform-independent
manner, ensuring that Java programs can access
consistent functionality across different systems.
 Standard Library: The Java standard library provides a
comprehensive set of core APIs that are included with
every Java installation. This standard library eliminates
 the need for developers to reinvent the wheel for
common tasks, promoting code reuse and portability.
 Third-Party Libraries: In addition to the standard library,
numerous third-party libraries and frameworks are
available for Java development. These libraries often
extend the capabilities of the core APIs and can be used
to create specialized applications or integrate with
external systems.
Combined Significance:
The combined power of the JVM and Java APIs is
fundamental to Java's platform independence and portability:
 Abstraction and Flexibility: The JVM's abstraction layer
and dynamic linking capabilities, coupled with the cross-
platform nature of Java APIs, provide developers with a
flexible and portable environment for building
applications.
 Developer Productivity: Java's rich API ecosystem
empowers developers to focus on creating innovative
solutions rather than reinventing the wheel for common
tasks.
 Ecosystem and Community: The vast Java ecosystem,
with its extensive community support and a wealth of
resources, further strengthens the platform's appeal and
ensures its continued evolution and growth.
Conclusion:
In conclusion, the JVM and Java APIs work together to form
the foundation of Java's platform independence and
portability. The JVM's role as a bytecode interpreter and
abstraction layer, combined with the cross-platform nature of
Java APIs, enables Java programs to run seamlessly on a wide
range of systems. This platform independence and portability
have contributed to Java's immense popularity and success as
a programming language.