Simple Bank System

SYNOPSIS OF THE PROJECT

Submitted by
Arpit Tripathi (23030405)
ASHUTOSH KUMAR (23030003)
BADAL SHARMA (23030267)
ANUJ KUMAR KASHYAP (23030130)
ARNAV TIWARY (23030611)

Submitted to
Mr. Manoj Pal

In Partial Fulfillment of the Requirements for

the Degree of

BACHOLAR OF TECHNOLOGY
4th SEM

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

QUANTUM UNIVERSITY

ROORKEE- 247167
 Session: 2024-25

INDEX

S NO Topics Page No.

1 Abstract 01

2 Introduction 02

3 Problem Analysis/ Literature Review 03-04

4 Proposed Methodology 05-08

5 Objectives 09
6 References 10
 ABSTRACT

The Simple Bank System is a mini-project undertaken to mimic the basic operations of a banking
app in a straightforward and user-centric way. It is a system that can aid users in simple banking
operations like opening a new account, login securely, inquire about account balance, depositing
cash, withdrawal of money, and transaction history viewing. The system offers interactive
functionality and utilizes a well-formatted database for storing and efficient management of the user
data.

Security is provided through authentication of users, where only registered users are permitted access
to their accounts. All transactions are traced to maintain transparency and traceability. Error handling
for unauthorized operations like overdraft or duplicate account creation is also provided.

Technologies employed in this project are [Java and MySQL], providing a real-world application of
database connectivity, CRUD operations, and simple user session management. The project
emphasizes clean code structure, simplicity, and robust performance, making it ideal for educational
use and as a base model for more complex banking applications.

This project emphasizes major programming principles like data validation, control structures,
file/database management, and UI/UX concepts. It is a hands-on demonstration of how technology
can be utilized to solve real-world financial issues in a simulated environment.

1|Page
 INTRODUCTION

Simple Bank System in Java is a console program that was built to exhibit the basic functions of
banking systems utilizing object-oriented programming and database/file management. As a secure,
efficient, platform-independent programming language that supports object-oriented programming,
Java presents an ideal environment in which secure and efficient programs like a bank system can be
constructed.

This project is intended to replicate basic banking operations like account opening, user logon,
balance checking, deposit, withdrawal . It targets the execution of these operations with simple logic
and organized coding, providing an experiential learning of actual banking systems at the basic level.

The system architecture employs Java classes and objects to represent real-world objects like
Account, User, and Transaction. Data is handled using either file handling or Java Database
Connectivity (JDBC) with MySQL for data persistence. Input validation and exception handling are
integrated to ensure the system is reliable and user-friendly.

By working on this project, students can get hands-on experience in fundamental Java concepts like:

• Classes and Objects

• Encapsulation and Inheritance

• Exception Handling

• File I/O or JDBC

• Loops and Conditionals

In general, the Simple Bank System is a solid foundation project for Java programming beginners and
provides an understanding of how fundamental concepts can be used to efficiently solve real-world
problems.

2|Page
 PROBLEM ANALYSIS

Banking is among the most critical services in any economy, processing transactions, customer
accounts, and financial information securely and reliably. With the advent of digital transformation,
the majority of banks utilize sophisticated software systems for running their operations. But these
systems tend to be complicated, costly, and not readily available for academic, training, or small-
scale simulation use.

For students or novice programmers learning Java, developing a Simple Bank System presents a
useful experience to learn and implement fundamental programming principles in the real world. The
primary difficulties this project will overcome are:

Unavailability of novice-friendly banking system models for educational use.

Unavailability of commercial banking software due to licensing or complexity.

Requirement for simple systems that emphasize core operations such as account creation, login,
deposits, withdrawals, and viewing transactions.

Knowing how to store and protect data with Java's core capabilities and optional database
functionality through JDBC.

This system is meant to work within a console-based or minimal GUI environment, with a focus on
logic, control flow, OOP, and minimal security. It sidesteps the complications of multi-threading,
network protocols, or enterprise frameworks at the outset, making it best suited for use in schools and
initial learning.

Banking applications in literature and business generally encompass large-scale distributed

applications, where scalability, real-time processing, and intricate security mechanisms become the
focus. Banking software at the enterprise level combines technologies such as Oracle, Spring Boot,
microservices, and layered architecture, which prove to be daunting for beginners at the beginner
level of programming.

Software engineering education research, as in [Ahmad et al., 2018], supports the notion that using
project-based learning with reduced systems (such as simple inventory or banking applications)
enhances learning of software architecture and problem-solving in practice. Java as a programming

3|Page
language is commonly used in universities because of the balance between simplicity and power, and
because it is used to develop standalone applications with extensive sets of features.

Earlier academic assignments and tutorials on basic banking systems in Java stress:

Utilization of Object-Oriented Programming (OOP) to model objects such as Account, User, and
Transaction.

The significance of File Handling or JDBC for storing data persistently.

Utilization of Exception Handling to handle runtime exceptions and invalid user input.

Utilization of Modular Code Structure for readability, maintainability, and scalability.

Although numerous open-source examples are available, few emphasize structured development
principles, good documentation, and extensibility. This project seeks to merge the best practices of
academia and industry to create a clean, modular, and extensible banking system prototype in Java.

The proposed system acts as a stepping stone towards more advanced applications with future
enhancements allowing for a graphical user interface (GUI), relation with relational databases,
encryption, multi-user access, and network communication.

4|Page
 PROPOSED METHODOLOGY

1. System Overview
The Simple Bank System proposed here is to have the fundamental banking operations in a well-
structured, object-oriented Java program. The approach is modular software development where
every module (e.g., account management, transaction processing, and user interface) is created,
tested, and integrated separately. The system will run through a command-line interface (CLI) and
optionally interact with a MySQL database through Java Database Connectivity (JDBC) for storage.

This project is built in steps to provide understanding, ease of maintenance, and proper
implementation of every feature. The main development method used for the software development
process is the Waterfall Model, which applies to small-level, well-recognized applications where
every step or phase is specifically known.

2. Development Stages
Phase 1: Requirements Analysis
Find out most critical functionalities required by the banking system:

Create/deletion account
Login/logoff user
Balance inquiry
Deposit and withdraw
Transaction report
Specify data input and output formats.
Specify whether the system should use database-based or file-based storage (JDBC + MySQL is
recommended).

Phase 2: System Design

Use Case Diagrams and Class Diagrams will be created to specify system behavior and interactions
between objects.

Specify the architecture with a layered approach:

Presentation Layer: Command-line user interface.
Business Logic Layer: Bank core logic and transaction processing.

5|Page
Data Access Layer: Does all reading/writing to files or talks to the database.
Specify object classes
Account, User, Transaction, BankSystem, DatabaseManager.

Phase 3: Implementation
Java SE (Standard Edition) will be used for programming with the following:
Object-Oriented Programming (OOP) for modeling the system.
Collections (ArrayList, etc.) for storing temporary data.
File I/O or JDBC for storing data persistently.
Authentication will be carried out with a username-password approach.
Transactions will be timestamped and will be retained for tracking history.
Use exception handling for system errors or invalid inputs.

Phase 4: Testing
Unit testing for all modules (login, deposit, withdrawal, etc.).
Integration testing to verify all pieces cooperate.
Boundary testing for invalid or out-of-range values (e.g., withdrawal of a negative amount).
Data validation and error handling tests.

Phase 5: Documentation & Finalization

User manual (CLI commands).
Code documentation via Java comments and Javadoc.
Database schema (in case MySQL is implemented).
3. Core Modules and Flow

A. User Module
Sign up, login, logout.
Validate credentials.
Store user session.

B. Account Module
Create account with unique ID.
Store basic information: name, contact, balance.
Modify account data.
Delete account at user request.

6|Page
C. Transaction Module
Deposit: Add money to balance, record transaction.
Withdraw: Subtract money, check for enough balance.
History: Display last few transactions with timestamps and values.

D. Data Management Module

File-based storage (for basic version):
Use text/CSV/serialized files.
Database-based storage:
MySQL with tables for users, accounts, and transactions.
JDBC API for connectivity.

E. Error Handling
Use try-catch blocks to catch exceptions such as:
Invalid input
Database errors
File not found
Gracious handling of system messages and user input.

4. Tools & Technologies

Programming Language: Java SE 8

IDE: Eclipse / IntelliJ IDEA / NetBeans
Database (optional): MySQL 8+ with JDBC drive
Development Methodology: Waterfall Model

Libraries/APIs:
java.util.* for collections and utilities
java.io.* for file operations
java.sql.* for JDBC

7|Page
5. Advantages of the Proposed Methodology
Modular Design: Independent and reusable for every function.
Scalable Structure: Features such as GUI or encryption can be integrated later.
Educational Value: Perfect to learn Java basics.
Secure and Structured: Simple validations and structured access control.
Database Integration Ready: Can be scaled from file-based to DBMS with ease.

6. Project Timeline (Tentative)

Phase Duration
Requirements Analysis 3 days
System Design 5 days
Implementation 10–12 days
Testing 4 days
Documentation & Finalization 3 days
Total Duration 25–30 days

8|Page
 OBJECTIVES
The main aim of this project is to create a Simple Bank System in Java that mimics the fundamental
banking operations of actual banking practices in a simplified and tutorial-oriented way. The aims of
this research and development work are as follows:

1. To Simulate Core Banking Operations

Provide simple banking functions including:

Account opening
Deposit and withdrawal
Balance enquiry
Transaction history viewing

2. To Apply Object-Oriented Programming (OOP) Concepts

Show application of OOP concepts like:

Encapsulation (data hiding)

Inheritance (code reuse)
Abstraction (simplified interface)
Polymorphism (method overloading/overriding)

3. To Maintain Data Persistence and Management

Save user and transaction information either:

Locally using file handling methods

4. To Implement Secure User Authentication

Create a secure login mechanism with password authentication to prevent unauthorized users from
accessing their account.

5. To Design a Modular and Scalable Codebase

Implement each module separately so the system can be expanded later with:

GUI (Swing/JavaFX)
Features such as OTP authentication, calculation of interest, etc.
9|Page
 REFERENCES

Example:

1. Schildt, H. (2018). Java: The Complete Reference (11th ed.). McGraw-Hill Education.
 A comprehensive guide on Java programming fundamentals and advanced features.
2. Keenan, A., & D'Anjou, P. (2017). Java 9 for Programmers (3rd ed.). Pearson.
 Offers practical insights into Java features, including the latest changes in Java 9.
3. Horstmann, C. (2019). Core Java Volume I—Fundamentals (11th ed.). Prentice Hall.
 Covers object-oriented principles in Java, key for understanding the development of modular
applications like the banking system.
4. Bloch, J. (2008). Effective Java (2nd ed.). Addison-Wesley Professional.
 A valuable resource for best practices and design patterns in Java programming.
5. Deitel, P. J., & Deitel, H. M. (2017). Java How to Program (11th ed.). Pearson.
 A beginner-friendly approach to learning Java with a focus on practical application
development.
6. Meier, D. (2019). Beginning Java 8 (3rd ed.). Wiley.
 Covers modern Java practices, including Streams and Lambda expressions, which are useful in
system development.
7. Aho, A. V., Ullman, J. D., & Lam, M. S. (2006). Compilers: Principles, Techniques, and Tools
(2nd ed.). Pearson.
 Although primarily about compilers, this text helps in understanding the underlying principles
of software development and optimization.
8. Cohen, D. (2018). Database Systems: Design, Implementation, & Management (13th ed.).
Cengage Learning.
 Provides foundational knowledge on relational databases, important for managing user and
transaction data.
9. Java Documentation. (2023). Java SE API Documentation. Oracle.
 The official Java documentation, essential for understanding core classes and libraries.
10. Chapin, A. H. (2020). Head First Java (2nd ed.). O'Reilly Media.
 An engaging and interactive approach to learning Java with a focus on building real-world
applications.
11. Y. Xu, X. Wei, & M. Liu. (2017). Design and Implementation of an Online Banking System.
International Journal of Computer Science and Information Technology, 9(4), 72-80.
 A study on the design and implementation of online banking systems, providing insights into
best practices.
12. Bishop, R. H. (2017). Pattern Recognition and Machine Learning. Springer.
 While focused on machine learning, this book offers a strong foundation in data processing
techniques that can be adapted for banking data analysis

10 | P a g e