INTERNSHIP REPORT

A report submitted in partial fulfillment of the requirements for the Award of

Degree of

MASTER IN COMPUTER APPLICATION

By
Soumya Ranjan Jena
Regd. No:2224100031

Under Supervision of

Mr. Rajesh Das

CodSoft
(Duration:5th August 2023 to 5th September 2023)

Odisha University of Technology & Research

(Formerly College of Engineering & Technology), ODISHA
Techno Campus, Ghatikia, Mahalaxmi Vihar, Bhubaneswar-751029
Year 2022-2023
 Odisha University of Technology & Research
(Formerly College of Engineering & Technology), ODISHA
Techno Campus, Ghatikia, Mahalaxmi Vihar, Bhubaneswar-751029
Year 2022-2023

CERTIFICATE

This is to certify that the “Internship report” submitted by Soumya Ranjan Jena
(Regd. No.:2224100031) is work done by her and submitted during 2023 – 2024
academic year, in partial fulfillment of the requirements for the award of the
degree of MASTER IN COMPUTER APPLICATION, at CODSOFT.

Signature of Signature of
Internship coordinator Head of School of Computer Science
 ACKNOWLEDGEMENT

First I would like to express my sincere appreciation for the incredible support and guidance I
have received during my internship at Codsoft. I would like to extend my heartfelt gratitude to
HR Mr. Rajesh Das, Head of the school of Computer Science Dr. Jibitesh Mishra,
Internship Coordinator Mrs. Rojalin Mallick, and all my colleagues who became friends
throughout this enriching experience.
First and foremost, I want to thank Mr. Rajesh Das for their warm welcome and continuous
support. Their insights into the company's policies and procedures have been invaluable, and
their approachability has made my integration into the company seamless.
I am immensely grateful to Dr. Jibitesh Mishra for his leadership and mentorship. His guidance
has not only enhanced my understanding of the industry but has also inspired me to strive for
excellence in my future endeavors.
Special appreciation goes to Mrs. Rojalin Mallick, whose dedication as the Internship
Coordinator has played a pivotal role in making my internship a well-organized and enriching
experience. Her support and encouragement have been instrumental in my professional
development.
This internship has been a remarkable journey, and I am grateful to have had the opportunity to
work with such a supportive team.
 ABSTRACT

Task-1: Number Game

Create a program that generates a random number within a specified range. Prompt the user to
guess the number, providing feedback on whether it's correct, too high, or too low. Include
options for limiting attempts, multiple rounds, and displaying the user's score.

Task-2: Student Grade Calculator

Develop a program that takes marks in each subject, calculates total marks, average percentage,
and assigns grades based on the average percentage. Display the results, including total marks,
average percentage, and the corresponding grade.

Task-3: ATM Interface

Build a class to represent an ATM machine, design a user interface for options like withdrawing
and depositing, and implement methods for these actions. Create a bank account class to store
the account balance and connect it with the ATM class. Validate user input, display messages
based on transactions, and ensure appropriate error handling.
 CONTENTS
Task-1: Number Game
1.1. Introduction
1.2. Project Scope
1.3. Existing System
1.4. Proposed System
1.5. Module Description
2. System Requirements
3. Project Schedule
4. Code Snippets
5. Output Screen
6. Conclusion
Task-2: Student Grade Calculator
1.1. Introduction
1.2. Project Scope
1.3. Existing System
1.4. Proposed System
1.5. Module Description
2. System Requirements
3. Project Schedule
4. Code Snippets
5. Output Screen
6. Conclusion
Task-3: ATM Interface
1.1. Introduction
1.2. Project Scope
1.3. Proposed System
1.4. Module Description
2. System Requirements
3. Project Schedule
4. Code Snippets
5. Output Screen
6. Conclusion

References
 Learning Objectives/Internship Objectives

⮚ Internships are generally thought of to be reserved for college students

looking to gain experience in a particular field. However, a wide array of
people can benefit from Training Internships in order to receive real world
experience and develop their skills.

⮚ An objective for this position should emphasize the skills you already
possess in the area and your interest in learning more

⮚ Internships are utilized in a number of different career fields, including

architecture, engineering, healthcare, economics, advertising and many
more.

⮚ Some internship is used to allow individuals to perform scientific research

while others are specifically designed to allow people to gain first-hand
experience working.

⮚ Utilizing internships is a great way to build your resume and develop skills
that can be emphasized in your resume for future jobs. When you are
applying for a Training Internship, make sure to highlight any special skills
or talents that can make you stand apart from the rest of the applicants so
that you have an improved chance of landing the position.
Task-1: Quiz Application
1.1. Introduction:

The Number Game project is designed to create an interactive guessing game where users can
attempt to guess a randomly generated number within a specified range. This document provides
an overview of the project, its scope, existing system (if any), proposed system, module
descriptions, system requirements, project schedule, code snippets, output screens, and a
conclusion.

1.2 . PROJECT SCOPE:

The project aims to create an engaging number guessing game with features like limiting
attempts, allowing multiple rounds, and displaying the user's score based on their performance.
The scope also includes implementing user-friendly feedback for each guess.

1.3. Existing System:

 Currently, there is no existing system for the Number Game.
1.4. Proposed System:
 The proposed system involves a Java application that generates random numbers,
accepts user guesses, and provides feedback until the correct number is guessed.
 It incorporates features like attempt limits, multiple rounds, and scoring.
 It will incorporate features such as random number generation, user input validation,
feedback generation, and options for multiple rounds.
1.5. Module Description:
 Random Number Generation: Generates a random number within a specified range.
 User Input: Accepts user guesses and validates input.
 Feedback: Provides feedback on user guesses (correct, too high, too low).
 Scoring: Keeps track of user score based on the number of attempts or rounds won.
 Game Loop: Manages the flow of the game, allowing multiple rounds.
 2. SYSTEM REQUIREMENTS

2.1. Software Requirement

o Java Development Kit (JDK)
o Integrated Development Environment (IDE)
o User-friendly console or GUI for interaction
2.2. Hardware Requirement
The hardware is very important in the existence and proper working of any software.
● Intel i5 12th Gen Processor
● 8 GB RAM
● 512 SSD
● Windows 11, 64-bit

3. PROJECT SCHEDULE:

Date Day Work

Requirement Analysis
05/08/23 Saturday

06/08/23 Sunday Design and Planning

Implementation
10/08/23 Thursday

Testing and Debugging

11/08/23 Friday

Documentation and
13/08/23 Sunday
Deployment
4. Code Snippets
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

public class NumberGameGUI extends JFrame {

private int lowerBound = 1;
private int upperBound = 100;
private int targetNumber;
private int attempts = 0;
private int rounds = 0;
private int score = 0;

private JLabel instructionLabel;

private JTextField guessField;
private JButton guessButton;
private JLabel resultLabel;
private JLabel scoreLabel;
private JButton newGameButton;

public NumberGameGUI() {
setTitle("Number Guessing Game");
setSize(400, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

instructionLabel = new JLabel("Guess the number between " + lowerBound + " and " +
upperBound + ":");
guessField = new JTextField(10);
guessButton = new JButton("Guess");
resultLabel = new JLabel("");
scoreLabel = new JLabel("Score: " + score);
newGameButton = new JButton("New Game");

JPanel panel = new JPanel();

panel.setLayout(new GridLayout(4, 1));
panel.add(instructionLabel);
panel.add(guessField);
panel.add(guessButton);
panel.add(resultLabel);
 panel.add(scoreLabel);
panel.add(newGameButton);

add(panel);

generateNewNumber();
guessButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
checkGuess();
}
});

newGameButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
startNewGame();
}
});
}

private void generateNewNumber() {

Random rand = new Random();
targetNumber = rand.nextInt(upperBound - lowerBound + 1) + lowerBound;
attempts = 0;
instructionLabel.setText("Guess the number between " + lowerBound + " and " +
upperBound + ":");
guessField.setText("");
resultLabel.setText("");
}

private void checkGuess() {

try {
int guess = Integer.parseInt(guessField.getText());
attempts++;

if (guess < targetNumber) {

resultLabel.setText("Too low! Try again.");
} else if (guess > targetNumber) {
resultLabel.setText("Too high! Try again.");
} else {
resultLabel.setText("Congratulations! You guessed the number in " + attempts + "
attempts.");
 score++;
scoreLabel.setText("Score: " + score);
guessButton.setEnabled(false);
}

guessField.setText("");
} catch (NumberFormatException e) {
resultLabel.setText("Please enter a valid number.");
}
}

private void startNewGame() {

generateNewNumber();
guessButton.setEnabled(true);
rounds++;
}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new NumberGameGUI().setVisible(true);
}
});
}
 5. Output Screen:

6. Conclusion:
The Number Game project in Java provides an interactive and entertaining experience for users
to guess randomly generated numbers. With features like multiple rounds and scoring, it offers
a fun and challenging environment. This document serves as a guide for understanding the
project, its development process, and system requirements.
Task-2: Student Grade Calculator

1.1. Introduction:
The Student Grade Calculator project is designed to create a program that calculates the total
marks, average percentage, and assigns grades based on the average percentage obtained in
various subjects. This document provides an overview of the project, its scope, existing
system (if any), proposed system, module descriptions, system requirements, project
schedule, code snippets, output screens, and a conclusion.

1.2. PROJECT SCOPE:

The project aims to develop a Java application for calculating total marks, average percentage,
and assigning grades to students based on their performance in multiple subjects. The scope
includes user-friendly input, accurate calculations, and clear grade assignments.

1.3. Existing System:

There is currently no existing system for the Student Grade Calculator as it is a new project.

1.4. Proposed System:

The proposed system involves creating a Java-based application that takes input for marks
obtained in each subject, calculates total marks, computes the average percentage, assigns
grades, and displays the results to the user.

1.5. Module Description:

 Input Handling
 Total Marks Calculation
 Average Percentage Calculation
 Grade Assignment
 Output Display
2. SYSTEM REQUIREMENTS

2.1. Software Requirement

 Java Development Kit (JDK)
 Integrated Development Environment (IDE) like IntelliJ
 User-friendly console or GUI for interaction
2.2. Hardware Requirement

The hardware is very important in the existence and proper working of any software.
● Intel i5 12th Gen Processor
● 8 GB RAM
● 512 SSD
● Windows 11, 64-bit

3. PROJECT SCHEDULE:

Date Day Work

Requirement Analysis
22/08/23 Tuesday

Design and Planning

23/08/23 Wednesday

Implementation
27/08/23 Sunday

Testing and Debugging

30/08/23 Wednesday

Documentation and
31/08/23 Thursday
Deployment
4. Code Snippets:
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class StudentGradeCalculator {

private JFrame frame;
private JTextField[] subjectFields;
private JLabel totalMarksLabel;
private JLabel averagePercentageLabel;
private JLabel gradeLabel;

public StudentGradeCalculator() {
frame = new JFrame("Student Grade Calculator");
frame.setLayout(new GridLayout(0, 2));
subjectFields = new JTextField[5]; // Assuming a maximum of 5 subjects
for (int i = 0; i < subjectFields.length; i++) {
frame.add(new JLabel("Subject " + (i + 1) + " Marks: "));
subjectFields[i] = new JTextField(5);
frame.add(subjectFields[i]);
}
JButton calculateButton = new JButton("Calculate");
calculateButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
calculateAndDisplayResults();
}
});
frame.add(calculateButton);
totalMarksLabel = new JLabel("Total Marks: ");
averagePercentageLabel = new JLabel("Average Percentage: ");
gradeLabel = new JLabel("Grade: ");
frame.add(totalMarksLabel);
frame.add(averagePercentageLabel);
frame.add(gradeLabel);

frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
private void calculateAndDisplayResults() {
int totalMarks = 0;
 int numberOfSubjects = 0;
for (JTextField subjectField : subjectFields) {
try {
int marks = Integer.parseInt(subjectField.getText());
totalMarks += marks;
numberOfSubjects++;
} catch (NumberFormatException e) {
// Handle invalid input here if needed
}
}
if (numberOfSubjects > 0) {
double averagePercentage = (double) totalMarks / (numberOfSubjects * 100);
String grade = calculateGrade(averagePercentage);
totalMarksLabel.setText("Total Marks: " + totalMarks);
averagePercentageLabel.setText("Average Percentage: " + (averagePercentage * 100)
+ "%");
gradeLabel.setText("Grade: " + grade);
}
}
private String calculateGrade(double averagePercentage) {
// You can implement your grading logic here based on the averagePercentage
// For example, you can use if-else statements to assign grades.
// Sample grading logic:
if (averagePercentage >= 0.9) {
return "A+";
} else if (averagePercentage >= 0.8) {
return "A";
} else if (averagePercentage >= 0.7) {
return "B";
} else if (averagePercentage >= 0.6) {
return "C";
} else {
return "F";
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new StudentGradeCalculator();
}
});
}
}
5. Output Screen:

6. Conclusion:
The Student Grade Calculator project in Java offers a straightforward and efficient solution for
calculating grades based on input marks. It provides a user-friendly interface and accurate
calculations to assist students in understanding their academic performance. This document
serves as a comprehensive guide for the project's understanding, development, and
deployment.
Task-3: ATM Interface

1.1. Introduction:
In the contemporary digital landscape, the development of an engaging and responsive
front-end for e-commerce platforms plays a pivotal role in ensuring user satisfaction and business
success. This report delves into the front-end design aspects of an e-commerce webpage
meticulously crafted using React.js, a powerful JavaScript library for building dynamic user
interfaces.

1.2. Project Scope:

The project involves developing an interactive ATM interface with options like
withdrawing, depositing, and checking the balance. It includes a user-friendly interface, secure
transaction handling, and appropriate feedback messages.

1.3. Proposed System:

The proposed system is a Java-based application that represents an ATM machine. It
includes a user interface for various options, such as withdrawing, depositing, and checking the
balance. The system connects with a bank account class to manage the user's account balance.

1.4. Module Description:

 User Interface Design
 Transaction Handling (Withdraw, Deposit, Check Balance)
 Bank Account Class
 Input Validation
 User Feedback
 Error Handling

2. SYSTEM REQUIREMENTS

2.1. Software Requirement

 Java Development Kit (JDK)

 Integrated Development Environment (IDE) like IntelliJ
 User-friendly console or GUI for interaction
 2.2. Hardware Requirement
The hardware is very important in the existence and proper working of any software.
● Intel i5 12th Gen Processor
● 8 GB RAM
● 512 SSD
● Windows 11, 64-bit

3. PROJECT SCHEDULE:
Date Day Work
14/08/23 Monday Requirement Analysis.

15/08/23 Tuesday Design and Planning.

18/08/23 Friday Implementation.

20/08/23 Sunday Testing and Debugging.

Documentation and
21/08/23 Monday
Deployment.
 4. Code Snippets:
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

// Create a class to represent the ATM machine

class ATM {
private double accountBalance;

public ATM(double initialBalance) {

accountBalance = initialBalance;
}

public void deposit(double amount) {

if (amount > 0) {
accountBalance += amount;
}
}

public boolean withdraw(double amount) {

if (amount > 0 && accountBalance >= amount) {
accountBalance -= amount;
return true;
}
return false;
}
public double checkBalance() {
return accountBalance;
}
}
// Create a class to represent the ATM GUI
public class ATMInterface2 {
private static ATM atm;

public static void main(String[] args) {

atm = new ATM(1000.0); // Initial account balance

// Create the main frame

JFrame frame = new JFrame("ATM Machine");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);

// Set the background color to blue

frame.getContentPane().setBackground(Color.BLUE);

// Create a heading label

JLabel headingLabel = new JLabel("WELCOME TO ATM MACHINE!");
headingLabel.setFont(new Font("Arial", Font.BOLD, 18)); // Set font and size
headingLabel.setHorizontalAlignment(JLabel.CENTER); // Center align the heading

// Create components
// JLabel balanceLabel = new JLabel("Balance: RS 0.0");
JTextField amountField = new JTextField(10);
JButton depositButton = new JButton("Deposit");
JButton withdrawButton = new JButton("Withdraw");
JButton checkBalanceButton = new JButton("Check Balance"); // New button

// Add components to the frame

JPanel panel = new JPanel();
 panel.setLayout(new GridLayout(5, 1)); // Use GridLayout for column-wise layout
panel.setBackground(Color.BLUE); // Set the background color of the panel to blue
panel.add(headingLabel); // Add the heading label
// panel.add(balanceLabel);
panel.add(amountField);
panel.add(depositButton);
panel.add(withdrawButton);
panel.add(checkBalanceButton); // Add the new button
frame.add(panel);
// Set up action listeners
depositButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String amountStr = amountField.getText();
try {
double amount = Double.parseDouble(amountStr);
if (amount > 0) {
atm.deposit(amount);
// balanceLabel.setText("Balance: Rs" + atm.checkBalance());
amountField.setText("");
JOptionPane.showMessageDialog(frame, "Deposit successful!");
} else {
JOptionPane.showMessageDialog(frame, "Invalid deposit amount!");
}
} catch (NumberFormatException ex) {
JOptionPane.showMessageDialog(frame, "Invalid input!");
}
}
});
withdrawButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String amountStr = amountField.getText();
 try {
double amount = Double.parseDouble(amountStr);
if (atm.withdraw(amount)) {
// balanceLabel.setText(String.format("Balance: Rs%.2f", atm.checkBalance()));
amountField.setText("");
JOptionPane.showMessageDialog(frame, "Withdrawal successful!");
} else {
JOptionPane.showMessageDialog(frame, "Insufficient funds or invalid input!");
}
} catch (NumberFormatException ex) {
JOptionPane.showMessageDialog(frame, "Invalid input!");
}
}
});

checkBalanceButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(frame, String.format("Current Balance: Rs%.2f",
atm.checkBalance()), "Balance", JOptionPane.INFORMATION_MESSAGE);
}
});
// Display the frame
frame.setVisible(true);
}
}
5. Output Screen
6. Conclusion:
The ATM Interface project in Java provides a simulated environment for users to interact
with an ATM machine. It ensures secure and user-friendly transactions, input validation, and
appropriate feedback. This document serves as a comprehensive guide for understanding the
project, its development, and deployment.
 REFERENCES

1. Java Documentation:
 Oracle Java Documentation
Official documentation provides comprehensive information about the Java
programming language, libraries, and tools.

2. Java Tutorials:
 Java Tutorials - Oracle
The official tutorials cover a wide range of Java topics and are suitable for both
beginners and experienced developers.

3. Java Programming Books:

 "Effective Java" by Joshua Bloch
 "Head First Java" by Kathy Sierra and Bert Bates
 "Java: The Complete Reference" by Herbert Schildt These books offer in-depth
knowledge, best practices, and tips for Java programming.

4. Online Learning Platforms:

 Codecademy
 Coursera
 edX