PRANVEER SINGH INSTITUTE OF TECHNOLOGY, KANPUR

DEPARTMENT OF ARTIFICIAL INTELLIGENCE AND MACHINE LEARNING

Even Semester 2025-26

B. Tech.- Second Year

Semester- IV

Lab File
OBJECT ORIENTED PROGRAMMIG USING JAVA
LAB
(BCS452)

Submitted To : Submitted By :
Faculty Name : Name :
Designation : Roll No. :
Section :
 Table of Contents
 Vision and Mission Statements of the Institute

 Vision and Mission Statements of the Department

 PEOs, POs, PSOs of the Department

 Course Objective and Outcomes

 List of Experiments

 Index
 Institute Vision Statement

To achieve excellence in professional education and create an ecosystem for the

holistic development of all stakeholders.

Institute Mission Statements

To provide an environment of effective learning and innovation transforming students

into dynamic, responsible, and productive professionals in their respective fields, who
are capable of adapting to the changing needs of the industry and society.
 Department Vision Statement

To be a recognized Department of Computer Science & Engineering that produces

versatile computer engineers, capable of adapting to the changing needs of computer
and related industry.

Department Mission Statements

The mission of the Department of Computer Science and Engineering is:

i. To provide broad based quality education with knowledge and attitude to succeed in
Computer Science & Engineering careers.

ii. To prepare students for emerging trends in computer and related industry.

iii. To develop competence in students by providing them skills and aptitude to foster
culture of continuous and lifelong learning.

iv. To develop practicing engineers who investigate research, design, and find workable
solutions to complex engineering problems with awareness & concern for society as
well as environment.

Program Educational Objectives (PEOs)

i. The graduates will be efficient leading professionals with knowledge of computer

science & engineering discipline that enables them to pursue higher education and/or
successful careers in various domains.

ii. Graduates will possess capability of designing successful innovative solutions to real
life problems that are technically sound, economically viable and socially acceptable.

iii. Graduates will be competent team leaders, effective communicators and capable of
working in multidisciplinary teams following ethical values.

iv. The graduates will be capable of adapting to new technologies/tools and constantly
upgrading their knowledge and skills with an attitude for lifelong learning
 Department Program Outcomes (POs)
The students of Computer Science and Engineering Department will be able:

1. Engineering knowledge: Apply the knowledge of mathematics, science, Computer Science &
Engineering fundamentals, and an engineering specialization to the solution of complex engineering
problems.

2. Problem analysis: Identify, formulate, review research literature, and analyze complex
engineering problems reaching substantiated conclusions using first principles of mathematics,
natural sciences, and Computer Science & Engineering sciences.

3. Design/development of solutions: Design solutions for complex Computer Science &

Engineering problems and design system components or processes that meet the specified needs
with appropriate consideration for the public health and safety, and the cultural, societal, and
environmental considerations.

4. Investigation: Use research-based knowledge and research methods including design of

experiments, analysis and interpretation of data, and synthesis of the information to provide valid
conclusions.

5. Modern tool usage: Create, select, and apply appropriate techniques, resources, and modern
engineering and IT tools including prediction and modelling to complex Computer Science &
Engineering activities with an understanding of the limitations.

6. The Engineering and Society: Apply reasoning informed by the contextual knowledge to assess
societal, health, safety, legal and cultural issues and the consequent responsibilities relevant to the
professional engineering practice in the field of Computer Science and Engineering.

7. Environment and sustainability: Understand the impact of the professional Computer Science
& Engineering solutions in societal and environmental contexts, and demonstrate the knowledge of,
and need for sustainable development.

8. Ethics: Apply ethical principles and commit to professional ethics and responsibilities and norms
of the Computer Science & Engineering practice.

9. Individual and team work: Function effectively as an individual, and as a member or leader in
diverse teams, and in multidisciplinary settings.

10. Communication: Communicate effectively on complex Computer Science & Engineering

activities with the engineering community and with society at large, such as, being able to
comprehend and write effective reports and design documentation, make effective presentations,
and give and receive clear instructions.

11. Project management and finance: Demonstrate knowledge and understanding of the Computer
Science & Engineering and management principles and apply these to one’s own work, as a member
and leader in a team, to manage projects and in multidisciplinary environments.

12. Life-long learning: Recognize the need for, and have the preparation and ability to engage in
independent and life-long learning in the broadest context of technological change.
 Department Program Specific Outcomes (PSOs)

The students will be able to:

1. Use algorithms, data structures/management, software design, concepts of

programming languages and computer organization and architecture.

2. Understand the processes that support the delivery and management of

information systems within a specific application environment.
 Lab Plan
SUBJECT NAME: Object Oriented Programming using Java Lab
SUBJECT CODE: BCS-452
Lab Schedule: As per the time table

i) Course Objective:
Students shall be able to design and implement object-oriented solutions to real life problems,
algorithmic problems and web application development using basic Java programming constructs,
Collection Framework and Java Spring Boot respectively.

ii) Course Outcomes

*Level of Bloom’s *Level of Bloom’s

Level to be met Level to be met
Taxonomy Taxonomy
L1: Remember 1 L2: Understand 2
L3: Apply 3 L4: Analyze 4
L5: Evaluate 5 L6: Create 6

CO Number Course Outcomes

To apply [3. Apply] object-oriented approach to solve real-life problems and the
BCS-452.1 compilation and interpretation process of JRE, take argument from command line
and eclipse platform.

To analyze [4. Analyze] Java Collection Framework and new language features
BCS-452.2
for efficient application development.

BCS-452.3
To develop [6. Create] and deploy web applications using Spring Boot.
 List of Experiments

Lab Correspo
Lab Experiment
No. nding CO
Write a simple Java program using Eclipse IDE to display the message "Hello, Java
World from Eclipse!" on the console, also use all major escape sequences including \n
1 (newline), \t (tab), \\ (backslash), \" (double quote), \' (single quote), and \r (carriage CO1
return). The program should demonstrate the basic structure of a Java application
including the main() method and [Link]() function for output.
Write a Java program that accepts two integer numbers as command-line arguments,
2 calculates their sum, and displays the result. Ensure that the program properly parses CO1
the command-line arguments and handles basic integer operations.
Write a Java program to create two classes: Student and Rectangle.
 The student class should have two data members: name and rollNo, with a
method to display the student's details.
3  The Rectangle class should have two data members: length and width, with a CO2
method to calculate and display the area of the rectangle.
Create objects for both classes, assign values to the data members, and invoke their
respective methods to display the output.
Write a Java program to demonstrate the concepts of inheritance and polymorphism:
 Create two classes, Animal and Dog, where Dog inherits from Animal to
demonstrate single-level inheritance.
 Override a method in the Dog class to demonstrate method overriding
(runtime polymorphism).
4 CO2
 Implement method overloading within the Dog class by creating multiple
versions of a bark() method with different parameters to demonstrate compile-
time polymorphism.
The program should create objects of the classes and invoke the methods to show the
behavior of inheritance, method overriding, and method overloading.
Write a Java program that demonstrates exception handling using try, catch, and finally
5 blocks to handle arithmetic exceptions. Extend the program to implement CO2
multithreading by creating and running two threads that print a message concurrently.
Write a Java program that creates a user-defined package named studentinfo,
containing a class Student with basic details. In another class, import this package and
6 CO2
display the student information, demonstrating the use of Java packages for modular
development.
Write a Java program that uses Java I/O streams to read data from a text file and write
7 data to another text file. The program should demonstrate file reading using CO2
FileReader and writing using FileWriter, along with proper exception handling.
Create a simple Spring-based Java application using annotation-based configuration.
The program should demonstrate dependency injection and include a service class and
8 CO3
a main class to invoke a method through Spring's @Component and @Autowired
annotations.
Develop a RESTful web service using Spring Boot. Create a controller that responds
9 to HTTP GET requests and returns a simple JSON message. Use Spring Boot CO3
annotations like @RestController and @GetMapping to handle requests.
Build a basic frontend web application using Spring Boot and Thymeleaf. Create a
webpage that collects user input from a form and displays the submitted data back
10 CO3
to the user. Demonstrate integration of backend logic with frontend rendering using
@Controller and Model.
 Date
Date of Faculty
Lab of
Lab Experiment Experim Marks Signat
No. Subm
ent ure
ission
Write a simple Java program using Eclipse IDE to display
the message "Hello, Java World from Eclipse!" on the
console, also use all major escape sequences including \n
(newline), \t (tab), \\ (backslash), \" (double quote), \'
1
(single quote), and \r (carriage return). The program should
demonstrate the basic structure of a Java application
including the main() method and [Link]()
function for output.
Write a Java program that accepts two integer numbers as
command-line arguments, calculates their sum, and
2 displays the result. Ensure that the program properly parses
the command-line arguments and handles basic integer
operations.
Write a Java program to create two classes: Student and
Rectangle.
 The student class should have two data members:
name and rollNo, with a method to display the
student's details.
3  The Rectangle class should have two data
members: length and width, with a method to
calculate and display the area of the rectangle.
Create objects for both classes, assign values to the data
members, and invoke their respective methods to display
the output.
Write a Java program to demonstrate the concepts of
inheritance and polymorphism:
 Create two classes, Animal and Dog, where Dog
inherits from Animal to demonstrate single-level
inheritance.
 Override a method in the Dog class to
demonstrate method overriding (runtime
4 polymorphism).
 Implement method overloading within the Dog
class by creating multiple versions of a bark()
method with different parameters to demonstrate
compile-time polymorphism.
The program should create objects of the classes and
invoke the methods to show the behavior of inheritance,
method overriding, and method overloading.
Write a Java program that demonstrates exception
handling using try, catch, and finally blocks to handle
5 arithmetic exceptions. Extend the program to implement
multithreading by creating and running two threads that
print a message concurrently.
Write a Java program that creates a user-defined package
named studentinfo, containing a class Student with basic
6
details. In another class, import this package and display
the student information, demonstrating the use of Java
 packages for modular development.
Write a Java program that uses Java I/O streams to read
data from a text file and write data to another text file.
7 The program should demonstrate file reading using
FileReader and writing using FileWriter, along with
proper exception handling.
Create a simple Spring-based Java application using
annotation-based configuration. The program should
8 demonstrate dependency injection and include a service
class and a main class to invoke a method through Spring's
@Component and @Autowired annotations.
Develop a RESTful web service using Spring Boot.
Create a controller that responds to HTTP GET requests
9 and returns a simple JSON message. Use Spring Boot
annotations like @RestController and @GetMapping to
handle requests.
Build a basic frontend web application using Spring
Boot and Thymeleaf. Create a webpage that collects
user input from a form and displays the submitted data
10
back to the user. Demonstrate integration of backend
logic with frontend rendering using @Controller and
Model.
 Experiment-1

Aim- Write a simple Java program using Eclipse IDE to display the message "Hello, Java World from
Eclipse!" on the console, also use all major escape sequences including \n (newline), \t (tab), \\ (backslash),
\" (double quote), \' (single quote), and \r (carriage return). The program should demonstrate the basic
structure of a Java application including the main() method and [Link]() function for output.

public class HelloWorld {

public static void main(String[] args) {
// Displaying basic message with newline
[Link]("Hello, Java World from Eclipse!\n");

// Demonstrating tab
[Link]("Column1\tColumn2");

// Demonstrating backslash
[Link]("Path: C:\\Users\\Java");

// Demonstrating double quote

[Link]("She said, \"Java is fun!\"");

// Demonstrating single quote

[Link]("Character: \'A\'");

// Demonstrating carriage return (overwrites beginning of line)

[Link]("Hello\rWorld");
}
}
 Experiment-2

Aim- Write a Java program that accepts two integer numbers as command-line arguments, calculates
their sum, and displays the result. Ensure that the program properly parses the command-line arguments
and handles basic integer
operations.

public class CommandLineSum {

public static void main(String[] args) {
if ([Link] == 2) {
try {
int num1 = [Link](args[0]);
int num2 = [Link](args[1]);
int sum = num1 + num2;
[Link]("The sum of " + num1 + " and " + num2 + " is: " + sum);
} catch (NumberFormatException e) {
[Link]("Error: Please provide valid integers.");
}
} else {
[Link]("Error: Please provide exactly two command-line arguments.");
}
}
}
 Experiment-3

Aim- Write a Java program to create two classes: Student and Rectangle.
• The student class should have two data members: name and rollNo, with a method to display the
student's details.
• The Rectangle class should have two data members: length and width, with a method to calculate and
display the area of the rectangle. Create objects for both classes, assign values to the data members, and
invoke their respective methods to display the output.

class Student {
String name;
int rollNo;

Student(String name, int rollNo) {

[Link] = name;
[Link] = rollNo;
}

void displayDetails() {
[Link]("Student Name: " + name + ", Roll No: " + rollNo);
}
}

class Rectangle {
double length;
double width;

Rectangle(double length, double width) {

[Link] = length;
[Link] = width;
}

void displayArea() {
[Link]("Area of Rectangle: " + (length * width));
}
}

public class ObjectsDemo {

public static void main(String[] args) {
Student student = new Student("Aarav", 101);
[Link]();

Rectangle rect = new Rectangle(5.5, 10.0);

[Link]();
}
}
 Experiment-4

Aim- Write a Java program to demonstrate the concepts of inheritance and polymorphism:
• Create two classes, Animal and Dog, where Dog inherits from Animal to demonstrate single-level
inheritance.
• Override a method in the Dog class to demonstrate method overriding (runtime polymorphism).
• Implement method overloading within the Dog class by creating multiple versions of a bark() method
with different parameters to demonstrate compile-time polymorphism.
The program should create objects of the classes and invoke the methods to show the behavior of
inheritance, method overriding, and method overloading.

class Animal {
void sound() {
[Link]("The animal makes a generic sound.");
}
}

class Dog extends Animal {

// Runtime Polymorphism: Method Overriding
@Override
void sound() {
[Link]("The dog barks: Woof! Woof!");
}

// Compile-time Polymorphism: Method Overloading (No parameters)

void bark() {
[Link]("Dog is barking once: Woof!");
}

// Compile-time Polymorphism: Method Overloading (With parameter)

void bark(int times) {
[Link]("Dog is barking " + times + " times: ");
for(int i = 0; i < times; i++) {
[Link]("Woof! ");
}
[Link]();
}
}

public class PolymorphismDemo {

public static void main(String[] args) {
// Single-level inheritance and overriding
Animal myDog = new Dog();
[Link]();

// Overloading
Dog specificDog = new Dog();
[Link]();
[Link](3);
}
}
 Experiment-5

Aim- Write a Java program that demonstrates exception handling using try, catch, and finally blocks to
handle arithmetic exceptions. Extend the program to implement multithreading by creating and running
two threads that print a message concurrently.

class ConcurrentThread extends Thread {

private String threadName;

ConcurrentThread(String name) {
[Link] = name;
}

public void run() {

for(int i = 1; i <= 3; i++) {
[Link](threadName + " is running. Count: " + i);
try {
[Link](500); // Small delay to show concurrency
} catch (InterruptedException e) {
[Link](e);
}
}
}
}

public class ExceptionThreadDemo {

public static void main(String[] args) {
// Exception Handling
try {
[Link]("Attempting to divide by zero...");
int result = 10 / 0;
} catch (ArithmeticException e) {
[Link]("Caught ArithmeticException: " + [Link]());
} finally {
[Link]("Finally block executed. Exception handling complete.\n");
}

// Multithreading
[Link]("Starting Threads...");
ConcurrentThread t1 = new ConcurrentThread("Thread A");
ConcurrentThread t2 = new ConcurrentThread("Thread B");

[Link]();
[Link]();
}
}
 Experiment-6

Aim- Write a Java program that creates a user-defined package named studentinfo, containing a class
Student with basic details. In another class, import this package and display the student information,
demonstrating the use of Java packages for modular development.

File 1: Save inside a folder/package named studentinfo as [Link]

package studentinfo;

public class Student {

public String name = "John Doe";
public String course = "[Link] CSE";

public void displayInfo() {

[Link]("Student Name: " + name);
[Link]("Enrolled Course: " + course);
}
}

File 2: Save in your main project folder as [Link]

import [Link]; // Importing the user-defined package

public class MainPackageDemo {

public static void main(String[] args) {
[Link]("Accessing data from studentinfo package:");
Student s = new Student();
[Link]();
}
}
 Experiment-7

Aim- Write a Java program that uses Java I/O streams to read data from a text file and write data to another
text file. The program should demonstrate file reading using FileReader and writing using FileWriter, along
with proper exception handling.

import [Link];
import [Link];
import [Link];

public class FileIODemo {

public static void main(String[] args) {
String inputFile = "[Link]";
String outputFile = "[Link]";

// Writing to a file
try (FileWriter writer = new FileWriter(inputFile)) {
[Link]("This is text written using FileWriter.\nJava I/O is powerful!");
[Link]("Data successfully written to " + inputFile);
} catch (IOException e) {
[Link]("Error writing to file: " + [Link]());
}

// Reading from the file and writing to another

try (FileReader reader = new FileReader(inputFile);
FileWriter writer = new FileWriter(outputFile)) {

int character;
[Link]("Reading from " + inputFile + " and copying to " + outputFile + "...");
while ((character = [Link]()) != -1) {
[Link](character);
}
[Link]("File copied successfully!");

} catch (IOException e) {
[Link]("Error processing file: " + [Link]());
}
}
}
 Experiment-8

Aim- Create a simple Spring-based Java application using annotation-based configuration. The program
should demonstrate dependency injection and include a service class and a main class to invoke a method
through Spring's @Component and @Autowired annotations.

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

// Service Class
@Component
class MessageService {
public void sendMessage() {
[Link]("Message from Service: Dependency Injection works!");
}
}

// Main App Class

@Component
class MainAppController {
@Autowired
private MessageService messageService;

public void execute() {

[Link]();
}
}

// Configuration
@Configuration
@ComponentScan(basePackages = "[Link]") // Update this to match your package
public class SpringAnnotationDemo {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext([Link]);
MainAppController app = [Link]([Link]);
[Link]();
[Link]();
}
}
 Experiment-9

Aim- Develop a RESTful web service using Spring Boot. Create a controller that responds to HTTP GET
requests and returns a simple JSON message. Use Spring Boot annotations like @RestController and
@GetMapping to handle requests.

import [Link];
import [Link];
import [Link];
import [Link];

@SpringBootApplication
@RestController // Combines @Controller and @ResponseBody
public class RestApiApplication {

public static void main(String[] args) {

[Link]([Link], args);
}

// Handles HTTP GET request

@GetMapping("/api/greet")
public String getGreeting() {
// Returning a simple JSON-formatted string
return "{\"status\": \"success\", \"message\": \"Hello from Spring Boot REST API!\"}";
}
}
 Experiment-10

Aim- Build a basic frontend web application using Spring Boot and Thymeleaf. Create a webpage that
collects user input from a form and displays the submitted data back to the user. Demonstrate integration of
backend logic with frontend rendering using @Controller and Model.

Java Controller:

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@SpringBootApplication
@Controller
public class FrontendWebApp {

public static void main(String[] args) {

[Link]([Link], args);
}

@GetMapping("/input")
public String showForm() {
return "input-form"; // Looks for [Link] in src/main/resources/templates
}

@PostMapping("/submitData")
public String handleData(@RequestParam("userName") String name, Model model) {
[Link]("submittedName", name);
return "display-data"; // Looks for [Link] in src/main/resources/templates
}
}

Thymeleaf Templates (Create these inside src/main/resources/templates/ folder):

[Link]:

<!DOCTYPE html>
<html>
<body>
<h2>Enter Your Information</h2>
<form action="/submitData" method="POST">
<label>Name:</label>
<input type="text" name="userName" required/>
<button type="submit">Submit</button>
</form>
</body>
</html>
[Link]:

<!DOCTYPE html>
<html xmlns:th="[Link]
<body>
<h2>Data Received Successfully!</h2>
<p>Welcome, <strong th:text="${submittedName}">User</strong>!</p>
</body>
</html>