MODULE -1

1. List and explain the features of Java language. Or List and explain the JAVA Buzzwords.
Ans:

• Object Oriented: In Java, everything is an Object. Java can be easily extended since it is based on
the Object model.
• Architecture-neutral: Java compiler generates an architecture-neutral object file format, which
makes the compiled code executable on many processors, with the presence of Java runtime system.
• Simple: Java is designed to be easy to learn. If you understand the basic concept of OOP Java, it
would be easy to master
• Secure: With Java's secure feature it enables to develop virus-free, tamper-free systems.
Authentication techniques are based on public-key encryption.
• Portable: Being architecture-neutral and having no implementation dependent aspects of the
specification makes Java portable. Compiler in Java is written in ANSI C with a clean portability
boundary, which is a POSIX subset.
• Robust: Java makes an effort to eliminate error prone situations by emphasizing mainly on
compile time error checking and runtime checking.
• Multithreaded: With Java's multithreaded feature it is possible to write programs that can perform
many tasks simultaneously. This design feature allows the developers to construct interactive
applications that can run smoothly
• Interpreted: Java byte code is translated on the fly to native machine instructions and is not stored
anywhere. The development process is more rapid and analytical since the linking is an incremental
and light-weight process.
• High Performance: With the use of Just-In-Time compilers, Java enables high performance.
• Distributed: Java is designed for the distributed environment of the internet.
• Dynamic: Java is considered to be more dynamic than C or C++ since it is designed to adapt to an
evolving environment. Java programs can carry extensive amount of run-time information that can
be used to verify and resolve accesses to objects on run-time.

2. Explain how Java is robust and Architectural neutral.

Ans:

Robustness in Java:
Java's robustness is mainly achieved through its emphasis on strong typing, exception handling, automatic
memory management (garbage collection), and runtime checking. These features help prevent common
programming errors and make it easier to write reliable and bug-free code. Here are some key points that
contribute to Java's robustness:
a. Strong Typing: Java enforces strict data type checking, ensuring that variables and expressions are used
in a consistent manner. This prevents type-related errors at compile time, reducing the likelihood of runtime
crashes.
b. Exception Handling: Java requires developers to handle exceptions explicitly, making it less prone to
unexpected failures. When an exception occurs, it can be caught, processed, and the program can continue
its execution gracefully.
c. Garbage Collection: Java manages memory automatically through a garbage collector. This feature frees
developers from explicitly deallocating memory, avoiding memory leaks and segmentation faults.
d. Array Bound Checking: Java automatically checks array bounds, preventing buffer overflow errors and
enhancing the overall stability of the code.
e. No Pointers: Java does not have pointer arithmetic, which eliminates the risk of directly accessing
arbitrary memory addresses and further enhances security and stability.

Architectural Neutrality in Java:

Java's architectural neutrality refers to its ability to run on various hardware and software platforms without
modification, making it highly portable. This is achieved through the following techniques:
a. Java Virtual Machine (JVM): Java code is compiled into an intermediate representation called
bytecode, which is platform-independent. The JVM, installed on each target platform, interprets this
bytecode, translating it into machine code that can be executed on the specific architecture.
b. Write Once, Run Anywhere (WORA): Because of the JVM and bytecode, Java programs are designed
to be "write once, run anywhere," meaning that once the code is compiled, it can be executed on any
platform with a compatible JVM implementation. This reduces development and deployment efforts for
cross-platform applications.
c. Platform-Specific Libraries: While Java code is portable, certain libraries or APIs might require
platform-specific implementations. Java handles this through abstract interfaces, allowing the JVM to
interact with the underlying system using platform-specific implementations while keeping the application
code platform-independent.
d. Java Standard Edition (SE) and Enterprise Edition (EE): Java is designed with modularity in mind.
Standard Edition provides a core set of libraries and features that are platform-independent. Enterprise
Edition builds on top of the standard edition, adding additional features for enterprise-level applications,
such as server-side technologies.
3. Discuss three Object-oriented principles. Or Explain Data Abstraction, Encapsulation, and
Polymorphism can be achieved in Java with a suitable example.
Ans:

The Three Object-Oriented Principles are

• Data Abstraction
• Encapsulation
• Polymorphism
 ➢ Data Abstraction:
Data abstraction is the process of hiding the implementation details of an object and exposing
only the relevant characteristics or behaviors to the outside world. In Java, data abstraction is achieved
through abstract classes and interfaces.

abstract class Animal {

public abstract void animalSound();

public void sleep() {

System.out.println("Zzz");

➢ Encapsulation
Encapsulation is the principle of bundling data (attributes) and the methods (functions) that operate
on that data within a single unit, i.e., an object. In Java, encapsulation is achieved through access
modifiers and getter and setter methods.
EX:

package com.javatpoint;
class Test{
public static void main(String[] args){
Student s=new Student();
s.setName("vijay");
System.out.println(s.getName());

➢ Polymorphism
Polymorphism is the ability of a class to take on multiple forms. In Java, polymorphism is achieved
through method overriding and method overloading.
EX; class Bike{
void run(){System.out.println("running");}
}
class Splendor extends Bike{
void run(){System.out.println("running safely with 60km");}
public static void main(String args[]){
Bike b = new Splendor();//upcasting
b.run();
}
}
4. Define Byte code. How does it help the Java program achieve portability? Or How “Compile once and
Run anywhere” is implemented in the Java language
Ans:
Java bytecode is the instruction set for the Java Virtual Machine.
Here's how bytecode helps Java achieve portability:

➢ Platform Independence: Bytecode is not specific to any particular hardware or operating system.
It is designed to be executed by the JVM, which acts as an abstraction layer between the bytecode
and the underlying system. Since the JVM is available for various platforms, the same bytecode
can be executed consistently across different environments without modification.
➢ "Write Once, Run Anywhere" (WORA) Principle: The generation of bytecode and its execution
by the JVM adhere to the "Write Once, Run Anywhere" principle. Once you compile your Java
source code into bytecode, you can distribute the bytecode to any machine with a compatible JVM.
As long as the JVM implementation is correct for that platform, the Java program will run as
expected.
➢ No Need for Re-compilation:With bytecode, you don't need to recompile your Java code for each
target platform. This saves development effort and time, making it easier to deploy and distribute
Java applications.
➢ Consistency in Behavior: Because bytecode is interpreted by the JVM, the behavior of a Java
program remains consistent across different platforms. This eliminates platform-specific quirks and
issues, providing a reliable and predictable execution environment.
➢ Security: Bytecode adds an additional layer of security since it cannot directly access the
underlying system resources. The JVM manages the bytecode execution, providing a controlled
environment for Java programs, reducing the risk of system-level vulnerabilities.
5. List down various operators available in Java and Explain any three with suitable examples.
Ans:
there are several types of operators
Arithmetic Operators: These operators perform basic arithmetic operations.
o Addition (+)
o Subtraction (-)
o Multiplication (*)
o Division (/)
o Modulus (%)
• Relational Operators: These operators compare two values and return a boolean result (true or
false).
o Equal to (==)
o Not equal to (!=)
o Greater than (>)
o Less than (<)
o Greater than or equal to (>=)
o Less than or equal to (<=)
• Logical Operators: These operators are used to perform logical operations and combine boolean
expressions.
o Logical AND (&&)
o Logical OR (||)
o Logical NOT (!)
• Bitwise Operators: These operators perform bit-level manipulation of values.
o Bitwise AND (&)
o Bitwise OR (|)
o Bitwise XOR (^)
o Bitwise NOT (~)
o Left Shift (<<)
o Right Shift (>>)
o Unsigned Right Shift (>>>)
 • Assignment Operators: These operators are used to assign values to variables.
o Assignment (=)
o Addition and Assignment (+=)
o Subtraction and Assignment (-=)
o Multiplication and Assignment (*=)
o Division and Assignment (/=)
o Modulus and Assignment (%=)
o Bitwise AND and Assignment (&=)
o Bitwise OR and Assignment (|=)
o Bitwise XOR and Assignment (^=)
o Left Shift and Assignment (<<=)
o Right Shift and Assignment (>>=)
o Unsigned Right Shift and Assignment (>>>=)
• These operators work with a single operand.
o Increment (++)
o Decrement (--)
o Unary Plus (+)
o Unary Minus (-)
o Logical NOT (!)
o Bitwise NOT (~)

6. Compare and explain the below two code snippets.

a. int num,den;
if (den!=0&&num/den>2)
{}
Ans:
In this snippet, the logical expression is written using the "&&" operator. This operator is
known as the "logical AND" operator. It checks if both conditions on its left and right sides are true
before proceeding to the execution of the code block inside the if statement.

den != 0: This condition checks whether the value of 'den' is not equal to zero. If 'den' is zero, it means
that the division 'num/den' will result in an error due to division by zero.
num/den > 2: This condition checks whether the result of the division 'num/den' is greater than 2.
If both conditions are true, the code block inside the if statement will be executed. If either
of the conditions is false, the code block will be skipped.
b. int num, den;
if(den!=0 & num/den>2 )
{}
Ans:
In this snippet, the logical expression is written using the single ampersand "&" operator. This
operator is known as the "bitwise AND" operator. Unlike the "logical AND" operator (&&), the bitwise
AND operator does not short-circuit the evaluation. It evaluates both sides of the expression, regardless of
whether the first condition is true or false.

den != 0: This condition checks whether the value of 'den' is not equal to zero, just like in snippet 'a'.
num/den > 2: This condition checks whether the result of the division 'num/den' is greater than 2, just like
in snippet 'a'.

or

Explain Short-circuit logical operators and Bitwise operators.

Ans:

Short-circuit Logical Operators:

In many programming languages, including Java, logical operators such as "&&" (logical AND)
and "||" (logical OR) are short-circuit operators. Short-circuiting means that the evaluation of the second
operand is skipped if the result of the expression can be determined by evaluating only the first operand.
This behavior is based on the logical properties of AND and OR operations.

a. Logical AND (&&):

The logical AND operator (&&) returns true if and only if both of its operands are true. When using
the short-circuit AND operator, if the left operand evaluates to false, the right operand is not evaluated
because the overall result of the expression is already determined to be false.
EX: boolean result = (5 > 3) && (4 < 2);

b. Logical OR (< >):

The logical OR operator {< >) returns true if at least one of its operands is true. With the short-
circuit OR operator, if the left operand evaluates to true, the right operand is not evaluated because the
overall result of the expression is already determined to be true.
EX: boolean result = (5 < 3) || (4 > 2);

Bitwise operators.
Bitwise operators perform operations on individual bits of integer types (byte, short, int, long) and
are used for low-level bit manipulation. These operators treat the operands as binary numbers and operate
on each corresponding bit.
a. Bitwise AND (&):
The bitwise AND operator (&) performs a bitwise AND operation between the individual bits of
two operands. The result has a 1 in each position where both operands have a 1.
EX;
int a = 5;
int b = 3;
int result = a & b;
System.out.println(result);
b. Bitwise OR (|):
The bitwise OR operator (|) performs a bitwise OR operation between the individual bits of two
operands. The result has a 1 in each position where at least one of the operands has a 1.
EX:
int a = 5;
int b = 3;

int result = a | b;
System.out.println(result);

c. Bitwise XOR (^):

The bitwise XOR operator (^) performs a bitwise exclusive OR operation between the individual
bits of two operands. The result has a 1 in each position where only one of the operands has a 1.
EX:
int a = 5;
int b = 3;

int result = a ^ b;
System.out.println(result);

8. Explain Type casting. Explain with an example. a. Briefly discuss The Java development tool kit
Or The Java environment Or The JVM.
Ans:
Type casting, also known as type conversion, is the process of changing the data type of a
variable from one type to another. In Java, type casting allows you to convert values between primitive
data types and perform conversions between object types in cases of inheritance or interface
implementations. There are two types of type casting:

Implicit Type Casting (Widening Conversion):

Implicit type casting occurs when Java automatically converts a smaller data type to a larger
data type without the need for explicit casting. It is also known as widening conversion. For example,
converting an int to a double or a float to a double.

Example of Implicit Type Casting

int numInt = 10;

double numDouble = numInt;
System.out.println(numDouble); // Output: 10.0

Explicit Type Casting (Narrowing Conversion):

Explicit type casting involves manually converting a larger data type to a smaller data type,
which may result in data loss as the target data type may not be able to represent the full range of
the source data type. Explicit casting is done by specifying the target data type in parentheses
before the variable.

Example of Explicit Type Casting:

double numDouble = 10.5;
int numInt = (int) numDouble;
System.out.println(numInt); // Output: 10 (decimal part is truncated)
The Java Virtual Machine (JVM):

The Java Virtual Machine (JVM) is a crucial component of the Java Runtime Environment (JRE) or
Java Development Kit (JDK). It is responsible for executing Java bytecode, which is the compiled form
of Java source code. The JVM provides a platform-independent runtime environment, enabling Java's
"write once, run anywhere" capability.

Key functions of the JVM:

• Bytecode Execution: The JVM interprets the platform-independent bytecode generated by the
Java compiler or can also use Just-In-Time (JIT) compilation to convert bytecode to machine
code at runtime for improved performance.
• Memory Management: The JVM automatically manages memory allocation and garbage
collection. It tracks objects that are no longer in use and frees up memory to avoid memory
leaks.
• Platform Abstraction: The JVM abstracts the underlying operating system and hardware,
providing a consistent runtime environment for Java applications across different platforms.
• Security: The JVM enforces various security measures to protect the system and ensure that
Java programs run within a secure sandbox environment.
• Class Loading: The JVM dynamically loads Java classes and ensures that class dependencies
are resolved at runtime.

The JVM is available for various platforms, such as Windows, macOS, Linux, etc., enabling Java
programs to be executed on different systems without modification, achieving Java's core principle of
platform independence.

9. Explain the process of building and running a Java application program.

Ans:
• Install Java Development Kit (JDK):
Ensure that you have the Java Development Kit (JDK) installed on your
system. The JDK includes the Java compiler (javac), the Java Virtual Machine (JVM),
and other necessary tools to develop and run Java programs. You can download the
latest JDK from the official Oracle website or OpenJDK distributions.

• Write Java Source Code:

Create a new text file and write the Java source code for your application. The
Java source code should have a ".java" extension. You can use any text editor or
Integrated Development Environment (IDE) for this purpose. For example, let's create
a simple Java program to print "Hello, World!" to the console:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Save the above code in a file named "HelloWorld.java".
 • Compile Java Source Code:
Open a terminal or command prompt and navigate to the directory where you
saved the "HelloWorld.java" file. Use the Java compiler (javac) to compile the Java
source code into bytecode. The compilation process creates a ".class" file for each class
in your program. In this case, the compiler will generate a "HelloWorld.class" file.

javac HelloWorld.java

• Run the Java Program:

After successful compilation, you can run the Java program using the Java
Virtual Machine (JVM). In the same terminal or command prompt, enter the following
command:
java HelloWorld

The JVM will execute the bytecode in the "HelloWorld.class" file, and you should see the output
"Hello, World!" displayed on the console.

10. Define a class and an object. Mention the difference between them.
Ans:

Class Object

Class is used as a template for declaring

and An object is an instance of a class.
creating the objects.

When a class is created, no memory is Objects are allocated memory space

allocated. whenever they are created.

The class has to be declared first and only An object is created many times as per
once. requirement.

A class can not be manipulated as they are

not Objects can be manipulated.
available in the memory.

A class is a logical entity. An object is a physical entity.

It is created with a class name in C++ and

It is declared with the class keyword
with the new keywords in Java.
Class Object

Class does not contain any values which Each object has its own values, which are
can be associated with the field. associated with it.

A class is used to bind data as well as

Objects are like a variable of the class.
methods together as a single unit.

Syntax: Instantiating an object for a Class

in C++ is as follows:
class Student {
public:
void put(){

Syntax: Declaring Class in C++ is as cout<<“Function Called”<<endl;

follows: }
class <classname> {};
}; // The class is declared here
int main(){
Student s1; // Object created
s1.put();
}

Example: Bike Example: Ducati, Suzuki, Kawasaki

11. Explain with an example Instance variable hiding and how to overcome the issue.
Ans:
Whenever you inherit a superclass a copy of superclass’s members is created at the subclass and
you using its object you can access the superclass members.
If the superclass and the subclass have instance variable of same name, if you access it using the
subclass object, the instance variables of the subclass hides the instance variables of the superclass
irrespective of the types. This mechanism is known as field hiding or, instance variable hiding.
class Super {
String name = "Krishna";
int age = 25;
}
class Sub extends Super {
String name = "Vishnu";
int age = 22;
public void display(){
Sub obj = new Sub();
System.out.println("Name: "+obj.name);
System.out.println("age: "+obj.age);
}
}
public class FieldHiding{
public static void main(String args[]){
new Sub().display();
}
}

Output:
Name: Vishnu
age: 22

12. What is Polymorphism? List the types of polymorphism and mention the feature provided by Java
to support the types.
Ans:
Polymorphism is a fundamental concept in object-oriented programming that allows
objects to take on multiple forms or behave differently based on their data types or context. It
enables a single interface (method or operator) to represent multiple implementations, providing
flexibility and extensibility in code design.

Types of Polymorphism:

Compile-time Polymorphism (Static Polymorphism):

• Method Overloading: In method overloading, multiple methods can have the same
name but different parameter lists (number or type of parameters). The compiler
determines which method to call based on the method signature during compile
time.
 • Operator Overloading: Operator overloading allows the same operator to have
different implementations depending on the types of operands involved.
Runtime Polymorphism (Dynamic Polymorphism):

• Method Overriding: In method overriding, a subclass provides a specific implementation

for a method that is already defined in its superclass. The decision on which method to call
is made at runtime based on the actual object type rather than the reference type.
• Interface Polymorphism: Java supports polymorphism through interfaces, allowing a class
to implement multiple interfaces and provide different behaviors for each interface method.

13. How static polymorphism can be achieved in Java. Explain with an example. Or Explain Method
Overloading in Java with a suitable example.
Ans:
Static polymorphism, also known as compile-time polymorphism or method overloading, can
be achieved in Java by using method overloading. Method overloading allows a class to have multiple
methods with the same name but different parameter lists (number or type of parameters). The Java
compiler determines which method to call based on the method signature during compile time.
Static polymorphism allows us to use a single method name for different implementations
based on the method signature, providing a convenient way to perform similar operations with different
types of data without having to use different method names.

public class MathOperations {

// Method to add two integers
public int add(int a, int b) {
return a + b;
}

// Method to add three integers

public int add(int a, int b, int c) {
return a + b + c;
}

// Method to add two double values

public double add(double a, double b) {
return a + b;
}
}

public class Main {

public static void main(String[] args) {
MathOperations math = new MathOperations();

int result1 = math.add(5, 10);

int result2 = math.add(3, 6, 9);
double result3 = math.add(2.5, 3.7);

System.out.println("Result 1: " + result1); // Output: Result 1: 15

System.out.println("Result 2: " + result2); // Output: Result 2: 18
 System.out.println("Result 3: " + result3); // Output: Result 3: 6.2
}
}

14. What are constructors? How constructors are different from Methods of a class.
Ans:
Constructors are special methods in a class that are used to initialize the state (data
members) of objects when they are created. They have the same name as the class and do not have
a return type, not even void. Constructors are automatically called when an object of a class is
created using the "new" keyword. They play a vital role in the object's lifecycle by setting up the
initial values of the object's attributes.

public class Car {

String make;
String model;
int year;

// Constructor with parameters

public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}

// Default constructor (no parameters)

public Car() {
this.make = "Unknown";
this.model = "Unknown";
this.year = 0;
}
}
15. Explain constructor overloading with a suitable example.
Ans:
Constructor overloading is the process of defining multiple constructors within a class,
each having a different parameter list. By providing multiple constructors, you can create objects
in different ways, allowing for greater flexibility and convenience when initializing objects with
different sets of attributes.

public class Student {

String name;
int age;
String department;

// Constructor with name and age parameters

public Student(String name, int age) {
this.name = name;
this.age = age;
this.department = "Undeclared";
}

// Constructor with all three parameters

public Student(String name, int age, String department) {
this.name = name;
this.age = age;
this.department = department;
}
 // Constructor with no parameters (default constructor)
public Student() {
this.name = "Unknown";
this.age = 0;
this.department = "Undeclared";
}

// Method to display student details

public void displayDetails() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Department: " + department);
}
}

16. Explain with an example how objects can be passed as arguments and how objects can be returned.
Ans:
In Java, objects can be passed as arguments to methods and can also be returned from
methods, allowing for more complex interactions between objects and enabling code reuse. When
an object is passed as an argument, the method can access and modify the object's state. Similarly,
when an object is returned from a method, the calling code can receive and use the object for
further operations.

public class Student {

String name;
int age;
String department;

// Constructor to initialize student attributes

public Student(String name, int age, String department) {
this.name = name;
this.age = age;
this.department = department;
}

// Method to display student details

public void displayDetails() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Department: " + department);
}
}
public class University {
// Method that takes a Student object as an argument
public static void printStudentDetails(Student student) {
System.out.println("Printing Student Details:");
student.displayDetails();
}

// Method that returns a Student object

public static Student createStudent(String name, int age, String department) {
return new Student(name, age, department);
}
}

public class Main {

public static void main(String[] args) {
// Creating a Student object
Student student1 = new Student("John Doe", 20, "Computer Science");

// Passing the Student object as an argument to a method

University.printStudentDetails(student1);

// Creating a Student object by invoking a method that returns a Student object

Student student2 = University.createStudent("Jane Smith", 22, "Mechanical Engineering");

// Displaying details of the returned Student object

System.out.println("\nDetails of Student created using method return:");
student2.displayDetails();
}
}
17. How arrays are defined in Java? Explain with an example.
Ans:
In Java, arrays are used to store a fixed-size collection of elements of the same data type. Arrays
provide a convenient way to work with multiple values of the same type as a single unit. They can be used
to store primitives (like int, char, etc.) as well as objects (like String, custom classes, etc.).Arrays in Java
are defined using the square brackets notation []. The general syntax to declare an array is as follows:

dataType[] arrayName;
public class ArrayExample {
public static void main(String[] args) {
int[] numbers = new int[5]; // Declaring and allocating space for an integer array
of size 5
// Initializing the array elements
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
}

18. Explain arrays of objects with suitable examples.

Ans:
Arrays of objects in Java allow you to store multiple instances of a class in a single array. This
means you can create an array where each element is an object of a specific class. This is particularly
useful when you want to work with a collection of objects of the same type.

Suppose we have a class called Student that represents students with attributes like name, age, and roll
number:

public class Student {

String name;
int age;
int rollNumber;

public Student(String name, int age, int rollNumber) {

this.name = name;
this.age = age;
this.rollNumber = rollNumber;
 }

public void displayDetails() {

System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Roll Number: " + rollNumber);
}
}
Now, let's create an array of Student objects:

public class Main {

public static void main(String[] args) {
// Creating an array of Student objects
Student[] students = new Student[3];

// Initializing each element of the array with a Student object

students[0] = new Student("John Doe", 20, 101);
students[1] = new Student("Jane Smith", 22, 102);
students[2] = new Student("Bob Johnson", 21, 103);

// Displaying details of all students in the array

System.out.println("Details of Students:");
for (int i = 0; i < students.length; i++) {
System.out.println("Student " + (i + 1));
students[i].displayDetails();
System.out.println();
}
}
}

19. Write a note on Creating and Destroying objects in Java. Or Write a short note on a] Garbage
Collection. b] new and constructor c] and finalize() method.
Ans:

Creating Objects:
• In Java, objects are created using the new keyword, which dynamically allocates memory for
the object at runtime.
• When an object is created, memory is allocated on the heap, and the object's state (data
members) is initialized, either through explicit assignments or by invoking constructors.
• Objects can be created for both built-in data types (e.g., int, double) and user-defined classes
(custom objects).
• Once an object is created, it can be accessed and manipulated through its reference.
Example of creating an object in Java:

public class Student {

String name;
int age;

public Student(String name, int age) {

this.name = name;
this.age = age;
}

public void displayDetails() {

System.out.println("Name: " + name);
System.out.println("Age: " + age);
}

public static void main(String[] args) {

Student student1 = new Student("John Doe", 20);
student1.displayDetails();
}
}

Destroying Objects (Garbage Collection):

• Java employs automatic memory management using a process called Garbage Collection (GC).
• When an object is no longer referenced by any active part of the program, it becomes eligible for
garbage collection.
• The Garbage Collector identifies and frees up memory occupied by unreachable objects, ensuring
efficient memory utilization.
• The JVM handles the Garbage Collection process internally, and as a programmer, you don't have
to explicitly deallocate memory or destroy objects

Example of object destruction

public class Main {
public static void main(String[] args) {
Student student1 = new Student("John Doe", 20);
student1 = null;

}
}
Write a short note on a] Garbage Collection. b] new and constructor c] and finalize() method.
Ans:
a] Garbage Collection (GC):
• Garbage Collection is an automatic memory management feature in Java that helps reclaim
memory occupied by objects that are no longer in use or unreachable. The primary goal of
GC is to free up memory and prevent memory leaks, ensuring efficient memory utilization
in Java programs
• When objects are created using the new keyword, memory is allocated on the heap.
However, objects may become unreachable due to references being lost or variables going
out of scope.
• The Garbage Collector periodically runs in the background, identifying and deallocating
memory occupied by unreachable objects.
• The GC process involves several algorithms, such as Mark and Sweep, Copying, and
Generational, to manage different types of objects and memory regions efficiently.
• As a programmer, you don't need to manually deallocate memory or destroy objects. The
JVM handles the Garbage Collection process internally.
• The System.gc() method can be used to request Garbage Collection, but it does not
guarantee immediate execution of the process.
b] new and Constructor:
• In Java, the new keyword is used to dynamically create objects at runtime. It allocates
memory for the object on the heap and initializes its state (data members) based on the
constructor called during object creation.
• The general syntax for creating an object is
ClassName objectName = new ClassName();.
• The new keyword is followed by the constructor call, which initializes the object's state.
Constructors are special methods with the same name as the class and no return type,
not even void.
• If a class does not explicitly define a constructor, Java provides a default constructor
with no parameters, which initializes the object's attributes with default values (e.g., 0
for integers, null for objects).
• Constructors can be overloaded, allowing a class to have multiple constructors with
different parameter lists, providing flexibility in object initialization.
 Example of using new and constructor to create objects in Java:
class Car {
String make;
String model;

// Constructor with parameters

public Car(String make, String model) {
this.make = make;
this.model = model;
}
}

public class Main {

public static void main(String[] args) {
// Creating objects using the new keyword and constructor
Car car1 = new Car("Toyota", "Corolla");
Car car2 = new Car("Honda", "Civic");
}
}
c] finalize() method:
• finalize() is a method defined in the Object class, which is the base class for all Java classes.
This method is called by the garbage collector before an object's memory is deallocated,
allowing the object to perform cleanup operations before being destroyed.
• The finalize() method is automatically called by the garbage collector when an object
becomes eligible for garbage collection.
• The default implementation of finalize() in the Object class does nothing. However, it can
be overridden in derived classes to perform specific cleanup tasks like releasing external
resources (e.g., closing files, network connections) held by the object.
• It is generally not recommended to rely on finalize() for critical cleanup tasks, as there is
no guarantee on when the garbage collector will run and when the finalize() method will
be invoked.
 • the finalize() method has been deprecated and considered for removal in future versions.
Instead, it is recommended to use try-with-resources or other appropriate cleanup
mechanisms to manage resources explicitly.
Example of overriding the finalize() method:
class MyClass {
protected void finalize() throws Throwable {
try {
} finally {
super.finalize();
}
}
}