Short-term Internship

On
Developing Java Based Banking Management System

A short-term internship report submitted in partial Fulfillment of

requirements for the award of degree in

BACHELOR OF TECHNOLOGY
IN
COMPUTER SCIENCE AND ENGINEERING

Under the esteemed guidance of

Dr.B.Thimma Reddy,
Associate Professor

Department of Computer Science and Engineering

G. PULLA REDDY ENGINEERING COLLEGE (Autonomous):KURNOOL

(Affiliated to JNTU, ANANTAPURAMU)

1
 2025-2026
G. PULLA REDDY ENGINEERING COLLEGE (Autonomous):

KURNOOL
(Affiliated to JNTU, ANANTAPURAMU)

Department of Computer Science and Engineering

A Short-term internship Report by

Avula Nithin Kumar Reddy
229X1A05K3

Dr.B.Thimma Reddy Dr. N. Kasiviswanath

Associate Professor, Professor and HOD,
Department of C.S.E., Department of
GPREC, Kurnool C.S.E., GPREC,

2
 Kurnool

G. Pulla Reddy Engineering College (Autonomous)

(Affliated to Jawaharlal Nehru Technological University, Anantapuramu.)

2025-2026
SHORT TERM INTERNSHIP DETAILS

Name of the College: G. Pulla Reddy Engineering College

Department: Computer Science and Engineering

Name of the Guide: Dr.B.Thimma Reddy, Associate Professor

Duration of the Internship: 6 weeks From : 05/05/25 To: 28/06/25

Name and address of the Organization: Six Phrase, Chennai

3
 Name of the Student: Avula Nithin Kumar Reddy

Program of Study: Computer Science and Engineering

Year of Study: 2025 - 2026

Register Number: 229X1A05K3

Internship Domain: JAVA

Internship Title: Developing a Java-Based Banking Management System.

Signature of Internship Coordinator

Dr. G. Rajeswarappa,
Associate Professor,
CSE Department,
GPREC
DECLARATION

I, Avula Nithin Kumar Reddy, a student of Bachelor of Technology Program, Reg. No. 229X1A05K3
of the Department of Computer Science and Engineering, G. Pulla Reddy Engineering College do hereby
declare that I have completed the mandatory internship from 05/05/25 to 28/06/25 in Java and Data
Structures under the Faculty Guideship of Dr.B.Thimma Reddy Associate Professor, Department of
Computer Science and Engineering, G.Pulla Reddy Engineering College (Autonomous), Kurnool.

4
 Certificate from Internship Organization

ACKNOWLEDGEMENTS

I wish to express my deep sense of gratitude to my internal supervisor Dr.B.Thimma Reddy,

Associate Professor of Computer Science and Engineering Department, G. Pulla Reddy
Engineering College.

My sincere thanks to our Internship Coordinator Dr.G.Rajeswarappa for his immaculate

guidance, constant encouragement and cooperation which have made possible to bring out this
internship work.

I am thankful to our Head of the Department Dr.N.Kasiviswanath, for his whole hearted support and
encouragement during the internship.

We are grateful to our Internship Dean Dr.Y.V.SivaReddy and to our respected Principal
Dr.B.SreenivasaReddy for providing requisite facilities and helping us in providing such a good
environment.

5
I wish to convey my acknowledgements to all the staff members of the Computer Science and
Engineering Department for giving the required information needed for my internship work.

I sincerely thank SixPhrase for providing me with the opportunity to pursue an internship in Java
and Data Structures. This experience has greatly enhanced my knowledge and practical skills in
the field

Finally, I wish to thank all our friends and well wishers who have helped me directly or indirectly
during the course of this internship work.

TABLE OF CONTENTS

S.No Description

1 Abstract

2 Overview Of The Organization

3 Activity Log for The Internship

4 Internship Report

5 Conclusion

6. References

6
 1. ABSTRACT

This project explores the design and implementation of a modern banking system that seamlessly combines
the functionalities of both traditional branch-based banking and contemporary online banking services. In
recent years, the banking sector has witnessed rapid technological advancements, and customer expectations
have evolved accordingly. To address these changes, this system is designed to offer a comprehensive solution
that caters to both in-person and remote banking needs.

The core features of the system include account creation, allowing users to register and manage their accounts
securely; balance enquiry, which enables real-time checking of account balances; and fund transfers,
facilitating quick and secure transactions between accounts. The system also provides mini statement
generation, helping users keep track of recent transactions, and digital record-keeping, ensuring that all
customer and transaction data is stored safely and can be easily retrieved when needed.
Special emphasis has been placed on creating a user-friendly interface that simplifies banking operations for
users with varying levels of digital literacy. The interface is designed to be intuitive, responsive, and
accessible across devices. Additionally, the system incorporates robust security mechanisms such as
encryption, authentication, and secure session management to safeguard user data and prevent unauthorized
access.

By integrating traditional and digital banking elements, this project aims to bridge the gap between
conventional banking practices and modern digital demands, offering a scalable, secure, and efficient
platform for both customers and banking institutions. The result is a flexible system capable of adapting to
the dynamic financial ecosystem, promoting financial inclusion, and enhancing customer satisfaction in
today’s digital era.

7
 CHAPTER – 2

OVERVIEW OF THE ORGANIZATION

Six Phrase: Empowering India’s Workforce Through Skill and Career Development

Six Phrase stands tall today as India’s largest Skill Development and Career Development
Enterprise, a beacon of transformation in the education and employability ecosystem. From
humble beginnings to becoming a national leader in career readiness and training, Six Phrase’s
journey is one of innovation, resilience, and dedication to empowering youth. With a powerful
mission of bridging the gap between academic learning and industry expectations, Six Phrase is
equipping millions of students with the tools and skills they need to thrive in a competitive job
market.

Origins Rooted in Industry Experience

The foundation of Six Phrase is deeply rooted in practical industry knowledge. The organization
is the brainchild of a seasoned IT professional who spent over 9 years at Cognizant Technology
Solutions, one of the leading global IT services companies. His firsthand exposure to the
challenges faced by fresh graduates in aligning with industry expectations sparked a strong desire
to create a platform that could address these issues at scale. From its inception over 14 years ago,
Six Phrase has consistently worked towards closing the employability gap. Today, it is
instrumental in launching the careers of more than 1.3 million students across India, an
achievement that reflects its unwavering commitment to student success.

A Journey of Transformation: From Vendor to Trusted Partner

What began as a modest training venture has now evolved into a trusted partner for educational
institutions, corporates, and governments across India. Over the years, Six Phrase has transformed
itself from merely being a training vendor to becoming a strategic partner in employability and
career development. This transition was not merely a change in status but a significant shift in
approach—Six Phrase doesn’t just deliver training programs; it co-creates customized, end-to-
end skill development solutions aligned with the needs of specific institutions and industry
sectors.

8
Core Services and Offerings

At the heart of Six Phrase's offerings is a comprehensive suite of services designed to equip students
with the necessary skills to succeed in their careers. The services offered include:
1. Placement and Employability Training

Six Phrase specializes in training students to become industry-ready by providing them with
comprehensive placement and employability programs. These programs are designed to improve
cognitive, technical, and soft skills and are aligned with the requirements of the corporate world.

2. Technical Training

In today’s digital-first world, technical skills are no longer optional. Six Phrase offers in-depth
training in various technical domains including programming languages, full-stack development,
databases, data structures and algorithms, and more. The technical modules are curated by
industry veterans and updated frequently to reflect the latest trends.

3. Aptitude and Soft Skills Training

No employability program is complete without a strong foundation in quantitative aptitude,

logical reasoning, verbal ability, and communication skills. Six Phrase has created scientifically
validated training modules in aptitude and soft skills, helping students ace competitive exams and
interviews alike.

4. English Language and Finance Training

To compete in a global job market, proficiency in English and a sound understanding of financial
concepts are critical. Six Phrase has dedicated modules to improve students’ English language
skills, especially for students from non-English backgrounds, and to build financial literacy to
make well-informed career and life choices.

5. Learning Management System (LMS) and E-Learning

The Six Phrase LMS is one of its most powerful offerings. This robust E-Learning platform allows
institutions and students to access a wide range of learning materials anytime, anywhere. The

9
platform supports video lectures, quizzes, assignments, progress tracking, and more—
empowering both instructors and learners.

6. Online Assessment Portal

With a growing demand for objective evaluation methods, Six Phrase also provides a feature-rich
Online Assessment Platform. It supports multi-format assessments, real-time analytics, and
performance diagnostics, helping institutions conduct mock tests, campus drives, and corporate
evaluations with ease.

Talentely: The Next Step in Talent Transformation

In its quest to create a holistic employability ecosystem, Six Phrase launched Talentely, a next-
generation platform that unifies the efforts of institutions, corporates, and students. Talentely is
not just another platform—it is a comprehensive career readiness ecosystem designed to
democratize talent discovery and development.

Talentely – A Unified Platform for Everyone

Talentely is designed with three major components:

1. LMS – Learning Management System

2. PMS – Profile Management System

3. TMS – Talent Management System.

10
 CHAPTER – 3

ACTIVITY LOG FOR THE INTERNSHIP

Week No Date Brief description of the daily activity Learning Outcome

Understood the scope and objectives of Gained insight into requirement
the Banking System. Researched core analysis, system planning, and
05-05-25 banking functionalities and explored real- the importance of user-focused
WEEK 1 to world systems. Identified key design in financial applications.
11-05-25 requirements like account creation, fund
transfers, and security measures.Started
planning the features and architecture
using a modular approach.

Designed the structure of the Banking Developed understanding of

12-05- System application. Created UML object-oriented programming
WEEK 2 25 diagrams for the Account and (OOP), UML modeling, and
to BankManagement classes. Defined class system design.
16-05-25 attributes, relationships, and methods
following OOP principles. Focused on
encapsulation, modularity, and
reusability.
Implemented the Account class in Java. Strengthened Java programming
19-05-25 Developed constructors, getter-setter and class-level design skills using
WEEK 3 to methods, and toString() representation. real-world entities.
23-05-25 Managed attributes like account number,
holder name, age, balance, etc. Ensured
encapsulation and field validation.
Developed the BankManagement class Learned how to
26-05-25 for managing user actions. Created implement controller
WEEK 4 To methods for account creation, update, logic, manage collections
31-05-25 deletion, and display. Handled user inputs (ArrayList), and build CLI
and managed a dynamic list of Account applications.
objects. Ensured proper menu navigation
and input validation using Scanner.
Implemented deposit, withdrawal, and Gained practical skills in
02-06-25 fund transfer functionalities. Created a transaction management, object
WEEK 5 to new Transaction class to track transaction composition, and user feedback
06-06-25 history. Integrated transaction logs and mechanisms.
printed mini-statements. Ensured balance
checks and error prompts.

11
 Implemented file I/O for saving and Learned to manage external file
09-06-25 loading accounts. Ensured persistence of storage and serialization in Java
WEEK 6 to data across program executions. Handled for real-world applications.
13-06-25 file reading, writing, and parsing using
Java I/O streams.

Identified and handled common Understood the importance of

16-06-25 exceptions. Added input validation and exception handling and how to
WEEK 7 to user-friendly error messages. Refined write robust, fault-tolerant
20-06-25 console menu and improved user programs.
experience. Professional communication
skills through feedback sessions.
Performed system testing with various Learned end-to-end software
inputs and scenarios. project lifecycle management
23-06-25 Documented the project: Introduction, from design to deployment and
WEEK 8 to Objective, Implementation, Output, reporting.
28-06-25 Challenges, and Conclusion.
Reviewed and compiled the internship
report.

12
 CHAPTER – 4

INTERNSHIP REPORT

INTRODUCTION:
The Banking System project is a comprehensive initiative focused on designing and developing a secure,
efficient, and user-friendly online banking application. The primary objective of this system is to empower
individuals with the ability to seamlessly manage their financial activities through a digital platform that is
both accessible and reliable. This application facilitates the creation of personal and business accounts,
enabling users to perform a wide range of financial operations such as deposits, withdrawals, money transfers,
and bill payments with ease and confidence.

By integrating core banking functionalities within a unified interface, the project aims to streamline the user
experience while maintaining high standards of data security and transactional integrity. Special emphasis is
placed on ensuring robust authentication mechanisms, data encryption, and fraud prevention features to
safeguard sensitive user information and prevent unauthorized access.

In addition to basic banking operations, the system is designed to support additional services such as
transaction history tracking, account statements, automated alerts, and customer support features, thereby
offering a holistic digital banking experience. The project also addresses key challenges such as system
scalability, cross-platform accessibility, and performance optimization to cater to a diverse and growing user
base.

Overall, this Banking System project aspires to bridge the gap between traditional banking practices and
modern digital solutions, offering users a convenient, secure, and efficient way to interact with their financial
institutions anytime, anywhere.

Objective of the Project

The objective of this Banking System project, developed by B.Tech Computer Science Engineering students,
is to design and implement a secure, efficient, and user-centric online banking application that simplifies
financial operations for users. The project aims to:
1. Facilitate Digital Banking: Enable users to create and manage bank accounts digitally, without the need
for physical visits to bank.
2. Support Core Banking Functions: Provide essential banking services such as deposits, withdrawals, fund
transfers, and bill payments in a seamless manner.
3. Ensure Security and Privacy: Implement robust authentication mechanisms, data encryption, and fraud
detection to protect users’ personal and financial information.
4. Enhance User Experience: Develop an intuitive and responsive interface that allows users to navigate and
complete transactions with ease.
5. Promote Accessibility: Design a platform that is accessible across multiple devices and platforms,
ensuring convenient use for all types of users.

13
Functional Requirements
1. User Registration & Login
Secure sign-up, login, and password recovery.
2. Account Management
Create/view/edit account details.

3. Transactions

Deposit, withdraw, and transfer funds securely.

4. Transaction History

View and filter past transactions and statements.

5. Bill Payments
Pay utility bills and manage billers.

6. Security

Data encryption, session timeout, and role-based access.

7. Admin Controls

Manage users, approve accounts, and monitor activity.

8. Notifications

Alerts for transactions, low balance, and due bills.

9. Customer Support

Submit feedback and raise service requests.

10. Cross-Platform Access

Compatible with desktop and mobile devices.

Technologies Used:
- Programming Language: Java/Python
- Database: MySQL/Oracle
- Frontend: HTML/CSS, JavaScript
- Backend: Node.js/Java Servlets
- Security: SSL/TLS, encryption techniques

Outcomes:
- Secure and user-friendly banking platform
- Easy account creation and management
- Instant money transfers and bill payments

14
 - 24/7 online accessibility
- Digital record-keeping for transparency and convenience
Project Structure:
1. Menu Choice (Integer)
At the main menu, the user enters a number to select an action:
- Create Account
- Update Account
- Delete Account
- View All Accounts
- Exit
2. Creating an Account (after choosing 1) o
- Enter Account Number (Integer)
- Enter Account Holder Name (String) — full name, may include spaces - Enter Age (Integer)
- Enter Account Type (String) — e.g., Savings, Current
- Enter Initial Deposit (Double) — e.g., 1000.00
- Enter Mobile Number (String) — for notifications
3. Updating an Account (after choosing 2)
- Enter Account Number to update (Integer)
- Enter new Account Holder Name (String)
- Enter new Age (Integer)
- Enter new Account Type (String)
- Enter new Balance (Double)
- Enter new Mobile Number (String)
4. Deleting an Account (after choosing 3)
- Enter Account Number to delete (Integer)
5. Viewing All Accounts (after choosing 4)
- No further input required; the system displays all account records.
6. Exit (after choosing 5) - Program terminates.

Class Diagram Description:

1. Account Class
The Account class is a data model class that encapsulates all attributes related to a bank account. It follows
object-oriented principles such as encapsulation and provides setter methods to update account details.
Attributes:
• accountNumber: int – Unique identifier for each account.
• accountHolderName: String – Full name of the account holder.
• age: int – Age of the account holder.
• accountType: String – Type of account (e.g., Savings, Current).
• balance: double – Current balance in the account.
• mobileNumber: String – Registered mobile number for notifications.

Methods:
• Constructor – Initializes all account attributes.

15
 • getAccountNumber(): int – Returns the account number (used for identification).
• setAccountHolderName(String name) – Updates the account holder's name.
• setAge(int age) – Updates the account holder's age.
• setAccountType(String type) – Updates the type of account.
• setBalance(double balance) – Updates the account balance.
• setMobileNumber(String number) – Updates the registered mobile number.
• toString(): String – Returns a string with all account details in a readable format.

2. Bank Management Class

The Bank Management class acts as the main controller of the application. It uses the Account class to
manage a collection of account records and handles all user-driven banking operations.
Attributes:
• accountList: ArrayList – Dynamically stores account objects.
• sc: Scanner – Reads input from the user via the console.
Methods:
• main(String[] args) – Entry point. Displays the menu and drives the application logic.
• createAccount() – Adds a new account after ensuring the account number is unique.
• updateAccount() – Updates an existing account’s details using the account number.
• deleteAccount() – Deletes an account record based on the account number.
• displayAccounts() – Displays all existing account records in a formatted list.

Relationships:
Usage Relationship:
The Bank Management class uses the Account class. It creates instances of Account, updates them, and
stores them in a list for further operations.
Visibility & Design:
• Private attributes enforce encapsulation to protect data.
• Public methods in Account offer controlled access to sensitive fields.
• The Bank Management class can be implemented with static methods for simplicity in a console-based
application.
• Class Diagram:

16
UML Diagram Description:
The UML class diagram illustrates the structure and relationships between the two primary classes: Account
and Bank Management.

Class: Account

Attributes:

• - Account Number: int

• - Account Holder Name: String
• - Age: int
• - Account Type: String - Balance: double
• - Mobile Number: String

All attributes are private, denoted by the minus (-) sign to enforce encapsulation and protect sensitive
data.

• Operations (Methods):
• + Account(accountNumber, accountHolderName, age, accountType, balance, mobileNumber)
(Constructor)
• + getAccountNumber(): int
• + setAccountHolderName(name: String): void

17
 • + setAge(age: int): void
• + setAccountType(type: String): void
• + setBalance(balance: double): void
• + setMobileNumber(number: String): void
• + toString(): String

All methods are public, denoted by the plus (+) sign, and provide controlled access to the private
attributes.

Class: BankManagement

Attributes:

• - accountList: ArrayList<Account> (static)

• - sc: Scanner (static)

Operations (Methods):

• + main(args: String[]): void (static)

• + createAccount(): void (static)
• +updateAccount(): void (static)
• +deleteAccount(): void (static)
• +displayAccounts(): void (static)

Most methods and attributes are static since the class is designed to manage system- wide account
records in a simple, console-based application.

Relationships

• Dependency / Usage:
The Bank Management class depends on the Account class. This is represented by a dashed
arrow from Bank Management to Account in the UML diagram. It shows that Bank
Management creates, modifies, and manages instances of the Account class

• Additional Notes

The UML diagram clearly shows encapsulation by keeping attributes private and providing public
methods for access and modification.
It emphasizes modular design:

• Account is responsible for data representation.

• Bank Management handles all system operations.
The use of static methods and attributes in Bank Management reflects a console-based, single- user
design, suitable for educational or prototype purposes.

18
Flow of Control:
Below is a simplified representation:

Account Creation Flowchart: Online Transaction Flowchart:

Approach:
• The Banking System is designed as a simple, console-based Java application using an object-
oriented programming (OOP) approach. The architecture is layered yet lightweight, focusing
on a clear separation between data representation and application logic.
• Data Model (Account Class):
Represents account details such as account number, account holder name, age, account type,
balance, and mobile number. This class encapsulates all account data and provides
appropriate getters and setters for accessing and modifying the information securely.

19
Application Logic (Bank Management Class):
Handles core banking functionalities including account creation, update, deletion, and display. It
manages a dynamic collection of Accountobjects using an Array List. The logic also includes input
validation (e.g., avoiding duplicate account numbers) and provides a menu-driven structure for user
operations.

• User Interaction:
The system operates via a Command-Line Interface (CLI). User inputs are captured using the
Scanner class. A text-based menu allows users to easily navigate the application without
needing a graphical interface, making it ideal for educational and prototype use.
• Data Storage:
Account records are stored in-memory using an Array List, and data persists only during the
runtime of the program. There is no database integration, which keeps the application simple
and focused on practicing core Java programming principles.
• Error Handling:
Basic input checks and validations are included. The system provides clear and user-friendly
messages to help users in case of invalid inputs, such as entering an existing account number
or invalid formats.
• Tools Used: o Java SE Development Kit (JDK) for developing and running the application o
Any standard Java IDE or text editor (e.g., Eclipse, IntelliJ IDEA, VS Code) o
Console/terminal for interacting with the program

Challenges Faced:

Duplicate Entry Checks:

Ensuring that each account number was unique required manual verification within the list before
adding a new account. This added complexity and required extra logic to prevent duplicate entries.

Updating and Deleting Logic:

Implementing reliable logic to search for accounts by account number and safely update or delete
them from the list was challenging. Careful handling was needed to avoid index errors and ensure
data consistency.

No Authentication or Access Control:

The system does not include login or security features, so anyone running the program can access
and modify all account data. In a real-world banking application, this would be a critical security
flaw.

Console-Only User Interface:

Designing an intuitive, user-friendly menu-driven interface using only the console was limiting. The
lack of visual elements made it less engaging and suitable only for basic use or demonstration
purposes.
Source Code:

20
 package BankingSystem;
import
java.util.ArrayList; class
Account
{
String name; int
accountNumber;
double balance;
ArrayList<Transaction> transactions = new ArrayList<>();
Account(String name, int accountNumber)
{ this.name = name;
this.accountNumber = accountNumber;
this.balance = 0.0;
}
void deposit(double amount)
{ balance += amount;
transactions.add(new Transaction("Deposit", amount));
}
boolean withdraw(double amount)
{ if (amount <= balance)
{ balance -=
amount;
transactions.add(new Transaction("Withdraw", amount)); return true;
} return
false;
} boolean transferTo(Account to, double
amount)
{ if (to == null)
{
System.out.println("Destination account does not exist."); return
false;
}
if (amount <= 0)
{
System.out.println("Invalid transfer amount.");
return false;
}
if (this.balance >= amount)
{ this.balance -= amount;
to.balance += amount;
return true;
}
else
{
System.out.println("Insufficient balance for transfer."); return
false;
}

21
 }

void printStatement()
{
System.out.println("\n--- Statement for Account: " + accountNumber + " ---"); for
(Transaction t : transactions)
{
System.out.println(t);
}
System.out.println("Current Balance: ₹" + balance);
}
public String toFileString()
{ return name + "," + accountNumber + "," + balance;
}
}
package
BankingSystem; import
java.io.*; import
java.util.*; class
Transaction
{
String type; double
amount;
Date date;
Transaction(String type, double amount)
{ this.type = type;
this.amount = amount;
this.date = new Date();
}
public String toString()
{ return type + ": ₹" + amount + " on " + date;
}
}
package BankingSystem;
import java.io.File; import
java.io.FileWriter; import
java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
class Bank
{
ArrayList<Account> accounts = new ArrayList<>(); static
int accountNumberSeed = 1001;
Account createAccount(String name)
{

22
 Account acc = new Account(name, accountNumberSeed++);
accounts.add(acc);
System.out.println("Account created: " + acc.accountNumber); return
acc;
}
Account findAccount(int accNo)
{ for (Account acc : accounts)
{ if (acc.accountNumber == accNo)
return acc;
} return
null;
}
void saveAccountsToFile(String filename) throws IOException
{
PrintWriter pw = new PrintWriter(new FileWriter(filename)); for
(Account acc : accounts)
{
pw.println(acc.toFileString());
} pw.close();
}
void loadAccountsFromFile(String filename) throws IOException {
File file = new File(filename);
if (!file.exists())
return;
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine())
{
String[] parts = scanner.nextLine().split(",");
Account acc = new Account(parts[0], Integer.parseInt(parts[1])); acc.balance =
Double.parseDouble(parts[2]);
accounts.add(acc);
}
scanner.close();
}
}
package BankingSystem;
import
java.io.IOException;
import java.util.Scanner;
public class
BankingSystem
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in); Bank
bank = new Bank();
try

23
 {
bank.loadAccountsFromFile("accounts.txt");
}
catch (IOException e)
{
System.out.println("Failed to load accounts.");
} while
(true)
{
System.out.println("\n--- Banking System Menu ---");
System.out.println("1. Create Account");
System.out.println("2. Deposit"); System.out.println("3.
Withdraw"); System.out.println("4. Transfer");
System.out.println("5. Mini Statement");
System.out.println("6. Exit"); System.out.print("Choose option:
");
int choice = sc.nextInt(); switch
(choice)
{ case 1:
System.out.print("Enter name: ");
sc.nextLine();
String name = sc.nextLine();
bank.createAccount(name);
break;
case 2:
System.out.print("Enter account number: "); int
accNo = sc.nextInt();
Account acc = bank.findAccount(accNo);
if (acc != null)
{
System.out.print("Enter amount to deposit: ");
double depositAmt = sc.nextDouble();
acc.deposit(depositAmt);
System.out.println(depositAmt+" Deposited successfully.");
}
else
{
System.out.println("Account not found.");
}
break;
case 3:
System.out.print("Enter account number: "); accNo
= sc.nextInt();
acc = bank.findAccount(accNo);
if (acc != null)
{

24
 System.out.print("Enter amount to withdraw: "); double
withdrawAmt = sc.nextDouble();
if (acc.withdraw(withdrawAmt))
{
System.out.println("Withdrawal successful.");
}
else
{
System.out.println("Insufficient balance.");
}
}
else
{
System.out.println("Account not found.");
}
break;
case 4:
System.out.print("From account: ");
int fromAcc = sc.nextInt();
System.out.print("To account: ");
int toAcc = sc.nextInt();
System.out.print("Amount to transfer: ");
double amt = sc.nextDouble(); Account from
= bank.findAccount(fromAcc); Account to =
bank.findAccount(toAcc); if (from != null
&& to != null)
{ if(from.transferTo(to, amt))
System.out.println("Transfer
completed.");
}
else
{
System.out.println("Invalid account(s).");
}
break;
case 5:
System.out.print("Enter account number: ");
accNo = sc.nextInt(); acc =
bank.findAccount(accNo);
if (acc != null)
{ acc.printStatement();
}
else
{
System.out.println("Account not found."); }
break; case 6:
try

25
 { bank.saveAccountsToFile("accounts.txt");
System.out.println("Accounts saved.
Exiting...");
}
catch (IOException e)
{
System.out.println("Failed to save accounts.");
} sc.close();
System.exit(0)
; break;
default:
System.out.println("Invalid option.");
}
}
}
}

26
OUTPUT:

27
Advantages and Disadvantages of the Banking System:
Advantages:
1. Financial Intermediation: Banks act as intermediaries between savers and borrowers,
efficiently channeling funds to productive uses, which helps drive economic growth.

2. Convenience: Banks provide easy access to financial services, such as deposits, loans, and
electronic transfers. Services like ATMs, mobile banking, and online banking make managing
money easier.

3. Security: Depositing money in a bank offers security against theft or loss. Most countries offer
deposit insurance schemes (e.g., FDIC in the U.S.) to protect small depositors.

4. Interest on Savings: Banks offer interest on savings accounts, which encourages individuals to
save and grow their wealth over time.

5. Credit Creation: Banks can create credit, which fuels economic growth by enabling businesses
to invest and consumers to spend. This helps drive demand and employment.

Disadvantages:
1. Over-reliance on Debt: The banking system heavily depends on credit creation, and this
reliance can lead to issues like high debt levels for individuals, businesses, and governments,
which can be unsustainable.

2. Interest Rates and Fees: While banks offer savings accounts with interest, the rates are often
low. Additionally, they charge fees for many services, like account maintenance, ATM use,
overdrafts, and loans, which can burden customers.

3. Economic Inequality: Access to banking and credit is not always equal. Low-income
individuals and communities may struggle to get loans, while high-income individuals or large
corporations have better access to financial resources.

4. Bank Failures: Although banks are generally secure, failures do occur, and when they do, they
can lead to significant losses for depositors (though deposit insurance often mitigates this risk).
The collapse of a large bank can also have a ripple effect on the entire economy.

5. Risk of Fraud and Cybersecurity Threats: As banking services become more digital, there’s
an increasing risk of cybersecurity breaches, fraud, and identity theft. Customers need to remain
vigilant, and banks must invest heavily in security measures.
Exception Handling:

InputMismatchException:
If the user enters letters instead of numbers (e.g., for fields like account number, age, or balance),
the program may crash with an InputMismatchException.Proper exception handling should be
implemented to validate and catch incorrect input types, ensuring the application responds with a
user-friendly error message instead of terminating unexpectedly.

28
 CHAPTER – 5

CONCLUSION

The banking system serves as a cornerstone of contemporary economies, underpinning the financial
infrastructure that enables societies to function smoothly and grow sustainably. It offers a wide range of
indispensable services, including financial intermediation—connecting savers with borrowers—
safeguarding deposits, facilitating payments, enabling credit creation, and providing access to capital for
individuals, businesses, and governments. These functions are vital for fostering entrepreneurship, supporting
business expansion, and promoting innovation, thereby contributing directly to overall economic growth and
societal progress.
Moreover, the banking system is central to international trade and global financial markets. Through
mechanisms such as foreign exchange, trade financing, and cross-border investments, banks help bridge
economies and foster international cooperation. The system also plays a stabilizing role during times of
economic uncertainty by implementing monetary policies through central banks and acting as a buffer against
financial shocks.

Despite these critical benefits, the banking system is not without significant challenges. One major concern
is its reliance on credit creation, which—if not managed prudently—can lead to excessive lending, asset
bubbles, and ultimately, financial crises. The 2008 global financial meltdown is a stark reminder of how
systemic risks within the banking sector can destabilize entire economies. Furthermore, the complex nature
of banking operations, along with regulatory and technological barriers, can unintentionally marginalize low-
income individuals, rural populations, and small businesses, limiting their access to essential financial
services.

In addition, while banks offer convenience, digital services, and enhanced financial security, they often
impose various fees, interest charges, and penalties that may disproportionately affect vulnerable segments
of society. This can contribute to widening the gap between economically privileged and underserved
communities, exacerbating financial inequality. The growing digitization of banking has also introduced new
forms of risk, such as cyberattacks, identity theft, and sophisticated online frauds, which threaten the integrity
and trust in the system.

Large-scale bank failures—whether due to mismanagement, poor regulatory oversight, or external shocks—
can trigger widespread economic disruption, loss of public confidence, and the need for taxpayer-funded
bailouts. To mitigate such risks, effective regulation, transparent governance, and strong risk management
practices are essential. Innovations like financial inclusion initiatives, ethical banking models, and the
integration of fintech solutions offer promising avenues to enhance the accessibility and fairness of banking
services.

In conclusion, while the banking system remains an indispensable driver of financial and economic
development, it is crucial that it evolves responsibly. Policymakers, regulators, and financial institutions must
work together to ensure that the system remains resilient, inclusive, and secure—capable of serving all
segments of society equitably while adapting to the challenges of an increasingly complex and interconnected
world.

29
 6. References

The following books are referred during the analysis and execution phase of the project

1.Oracle Java Documentation –

https://docs.oracle.com/javase/8/docs/
2.Java Collections Framework Guide –
https://docs.oracle.com/javase/tutorial/collections/
3.GeeksforGeeks - Java OOPs Concepts –
https://www.geeksforgeeks.org/object-oriented-programming-oops-concept-in-java/
4.TutorialsPoint - Java Exception Handling –
https://www.tutorialspoint.com/java/java_exceptions.html
5.Java (software platform) – Wikipedia – overview including versions, JCP, etc.:
https://en.wikipedia.org/wiki/Java_(software_platform)
6.StackOverflow on using Weak and Phantom References –
https://stackoverflow.com/questions/11397522/references-in-javaStack Overflow
7.Java Language and Virtual Machine Specification –
https://docs.oracle.com/javase/specs/
8.JavaArrays –
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html
9.Functions and Methods –
https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html

10.Method Overloading –
https://www.geeksforgeeks.org/method-overloading-in-java

11.Basic Data Structures –

https://www.geeksforgeeks.org/data-structures

12.Talentely– Java Practice Portal –

https://talentely.com
13. Debugging in Java (IDE Console) –
https://www.jetbrains.com/debugging-code.html
14.Menu-Driven Program Design –

30
https://www.geeksforgeeks.org/menu-driven-program-in-java
15.Java Naming Conventions –
`https://www.javatpoint.com/java-naming-convention

31
 Student Self Evaluation of the Short-Term Internship

Student Name: & Registration No: Avula Nithin Kumar Reddy & 229X1A05K3
Term of Internship: From 05-05-2025 To 28-06-2025
Date of Evaluation:
Organization Name & Address: SixPhrase, Chennai
Name & Address of the Supervisor: Dr.B.Thimma Reddy, GPREC, Kurnool
Mobile Number:

Please rate your performance in the following areas:

Rating Scale: Letter grade of CGPA calculation to be provided

1) Oral communication 1 2 3 4 5

2) Written communication 1 2 3 4 5

3) Initiative 1 2 3 4 5

4) Interaction with staff 1 2 3 4 5

5) Attitude 1 2 3 4 5

6) Dependability 1 2 3 4 5

7) Ability to learn 1 2 3 4 5

8) Planning and organization 1 2 3 4 5

9) Professionalism 1 2 3 4 5

10) Creativity 1 2 3 4 5

11) Quality of work 1 2 3 4 5

12) Productivity 1 2 3 4 5

13) Progress of learning 1 2 3 4 5

14) Adaptability to organization’s culture/policies 1 2 3 4 5

15) Overall Performance 1 2 3 4 5

Signature of the Student

32
 Evaluation by the Supervisor of the Intern Organization

Student Name: & Registration No: Avula Nithin Kumar Reddy & 229X1A05K3
Term of Internship: From 05-05-2025 To 28-06-2025
Date of Evaluation:
Organization Name & Address: SixPhrase , Chennai
Name & Address of the Supervisor: Dr.B.Thimma Reddy, GPREC,Kurnool
Mobile Number:

Please rate the student’s performance in the following areas:

Please note that your evaluation shall be done independent of the Student’s self-evaluation
Rating Scale: 1 is lowest and 5 is highest rank

1) Oral communication 1 2 3 4 5

2) Written communication 1 2 3 4 5

5) Initiative 1 2 3 4 5

6) Interaction with staff 1 2 3 4 5

5) Attitude 1 2 3 4 5

8) Dependability 1 2 3 4 5

9) Ability to learn 1 2 3 4 5

8) Planning and organization 1 2 3 4 5

9) Professionalism 1 2 3 4 5

10) Creativity 1 2 3 4 5

11) Quality of work 1 2 3 4 5

16) Productivity 1 2 3 4 5

17) Progress of learning 1 2 3 4 5

18) Adaptability to organization’s culture/policies 1 2 3 4 5

19) Overall Performance 1 2 3 4 5

Signature of the Supervisor

33