Contents

1 Introduction 3
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Implementation of the Project 4

2.1 Development Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.1 LogIn.Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.2 Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.3 Frame1.class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.4 Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3 Interface Snapshots 15
3.1 LogIn page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Conclusion 18
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2 Practical Implications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Scope of Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

1
Abstract

The Money Handler System is a Java-based application that manages financial trans-
actions by generating, adding, and updating records in real-time. It allows users to
securely add their names and product details and saves the information in a local
database. The system is designed using Java Swing and MySQL database. The project
includes a login page and a frame that collects and sends information to the server. The
purpose of this system is to hold information about the product and it is easy to use
and interact with. Overall, the Money Handler System is a user-friendly and efficient
way to manage financial records.

Figure 1: Project

2
Chapter 1

Introduction

1.1 Introduction
Money Handler is a Java-based system designed to simplify the process of managing
financial records for products. The system uses Java Swing to create a user-friendly
interface, and MySQL database to store and manage data. The purpose of the system
is to hold information about different products and provide an easy-to-use platform for
users to interact with the data.
The system includes a login page for user authentication, and a frame for entering and
sending product information to the server. Money Handler is designed to be efficient,
secure, and easy to use, allowing users to store, manage, and update financial records
easily.

1.2 Objectives
The core objective of this project is to design a system with java swing and SQL for
learning purposes but there are more. [5] [4]
• To streamline the process of managing financial records for products, making it
more efficient and less time-consuming.
• To provide a user-friendly interface that allows users to easily enter and retrieve
product information. To improve data accuracy and reduce errors in financial
records by providing a centralized database for storing and managing product
information.
• To enhance data security by implementing user authentication and access con-
trol features, ensuring that only authorized users can access and modify product
information.
• To provide real-time updating of financial records, making it easy for users to keep
track of changes in product information over time.
• To improve decision-making by providing accurate and up-to-date financial infor-
mation that can be used to inform business strategies and decisions.
• To reduce the risk of data loss by providing a reliable backup and recovery system
that ensures that product information is not lost due to system failures or other
issues.

3
Chapter 2

Implementation of the Project

2.1 Development Tools

1. Text Editor
2. A compiler like JVM
3. Programming language Java
4. GUI
5. A local pc to load and save the file
6. IDE used VS Code
[1]

2.2 Implementation
2.2.1 LogIn.Class

package handlersys;

//import javax.swing.ImageIcon;
//import javax.swing.JFrame;
import java.awt.Color;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPasswordField;
import javax.swing.JTextField;

public class loginframe extends JFrame {

private ImageIcon icon, cover;

private Container C;

4
private JLabel userlabel1, userlabel2, userlabel3;
private JLabel imgLabel;
private JTextField tf1;
// private JTextField tf2;
private JPasswordField passf;
private JButton btn1, btn2;
private Cursor cursorhand;

private Font h1f, h2f, h3f, h4f;

loginframe() { // constructor
initComponents();
}

public void initComponents() {

C = getContentPane(); // Asigning content frame to C which is a object.
C.setLayout(null); // setting to null because of manually setting the object in
the frame

h2f = new Font("Arial", Font.BOLD, 18); // creating font name,type,size

h1f = new Font("Arial", Font.BOLD, 24);
h3f = new Font("Georgia", Font.BOLD, 20);
h4f = new Font("Georgia", Font.BOLD, 13);

C.setBackground(Color.DARK_GRAY); // set content frame background color

// creating img,icon object

icon = new ImageIcon(getClass().getResource("app_icon.png")); // import icon ,
IMAGE
cover = new ImageIcon(getClass().getResource("Money Handler (2).png")); // setting
background Cover of the
// content frame
this.setIconImage(icon.getImage()); // set icon to the app
imgLabel = new JLabel(cover);

// Creating JLabel
userlabel1 = new JLabel(); // created JLabel object
userlabel2 = new JLabel(" To Begin Enter your Username: "); // set text Jlabel
userlabel3 = new JLabel(" Enter your Password: ");
userlabel1.setText(
" Welcome to The World’s Best Personal Fiancial App. :,)"
);

userlabel1.setFont(h1f); // set font to object

userlabel2.setFont(h2f);
userlabel3.setFont(h2f);

userlabel1.setForeground(Color.black); // set font color

userlabel1.setOpaque(true); // Enabling font background

userlabel2.setOpaque(true);
userlabel3.setOpaque(true);

userlabel1.setBackground(Color.white); // setting font background color

userlabel2.setBackground(Color.white);
userlabel3.setBackground(Color.white);
// userlabel3.setBackground(Color.CYAN);
// userlabel3.setBackground(Color.CYAN);

// creating JtextField, JPassField, JButton, cursor

cursorhand = new Cursor(Cursor.HAND_CURSOR);

5
tf1 = new JTextField();
tf1.setFont(h2f);
// tf1.setCursor(cursor2);
// tf2 = new JTextField();
passf = new JPasswordField();
passf.setEchoChar(’*’);
passf.setFont(h3f);

// Reset Password
btn1 = new JButton("Reset Password");
btn1.setFont(h4f);
btn1.setForeground(Color.BLACK);
btn1.setBackground(Color.WHITE);
btn1.setCursor(cursorhand);

// Set Account
btn2 = new JButton("Create new Account");
btn2.setFont(h4f);
btn2.setForeground(Color.BLACK);
btn2.setBackground(Color.WHITE);
btn2.setCursor(cursorhand);

// setting Location
userlabel1.setBounds(20, 40, 637, 30); // setting location of the Jlabel textfield
userlabel2.setBounds(50 + 85, 310 + 60, 290, 30);
userlabel3.setBounds(50 + 85, 350 + 60, 290, 30);
imgLabel.setBounds(0, 0, cover.getIconWidth(), cover.getIconHeight());
// imgLabel.setBounds(10, 10, cover.getIconWidth(),cover.getIconHeight());
// imgLabel.setBounds(0, 0, 690,280);
tf1.setBounds(355 + 85, 310 + 60, 290, 30);
tf1.setHorizontalAlignment(JTextField.CENTER);
passf.setBounds(355 + 85, 350 + 60, 290, 30);
passf.setHorizontalAlignment(JPasswordField.CENTER);
// tf2.setBounds(355 + 85, 350 + 60, 290, 30);
// tf2.setHorizontalAlignment(JTextField.CENTER);
btn1.setBounds(20, 100, 160, 25);
btn2.setBounds(190, 100, 190, 25);

// action listener
tf1.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String S = tf1.getText();
if (S.isEmpty()) {
JOptionPane.showMessageDialog(null, "Please Enter name");
} else {
passf.requestFocusInWindow();
}
}
}
);

passf.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
char[] passwordChars = passf.getPassword();
String S1 = new String(passwordChars);
String S = tf1.getText();

if (S1.isEmpty() || S.isEmpty()) {

6
 JOptionPane.showMessageDialog(
null,
"Please Enter Password or Username"
);
} else if (S.equals("Sabbir") && S1.equals("abc")) {
dispose();
frame1 frame = new frame1();
frame.setVisible(true);
} else {
JOptionPane.showMessageDialog(
null,
"Incorrect password or Username"
);
}
}
}
);

btn1.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null, "You resetted your password");
}
}
);

btn2.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null, "Created Account");
}
}
);

C.add(userlabel1); // show the text in the content frame

C.add(userlabel2);
C.add(userlabel3);
C.add(btn1);
C.add(btn2);

C.add(imgLabel);
C.add(tf1);
C.add(passf);
// C.add(tf2);

public static void main(String[] args) {

loginframe frame = new loginframe();
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// frame.setSize(704, 440);
frame.setSize(920, 518);
frame.setTitle("Money Handler System (BETA)");
frame.setResizable(false);
}
}

7
2.2.2 Algorithm

Algorithm 1: Search using thread

Input: N
Result: Found by Thread No: ” index id”. The index is ”index number”
1 Start ;
2 Create a JFrame object called loginframe. ;
3 Define variables for the user interface components, such as text fields, password
fields, buttons, and labels. ;
4 Set the fonts, colors, and layout of the user interface components.;
5 Set the background of the content frame and add an image to the frame.;
6 Define the location of the user interface components on the frame.;
7 Create action listeners for the text fields, password fields, and buttons;
8 In the action listener for the text field, check if the user has entered a name. If
not, display an error message. If yes, move the focus to the password field.;
9 In the action listener for the password field, check if the user has entered a
password and a username. If not, display an error message. If yes, check if the
username and password match what is expected. If the user enters the correct
username and password, close the loginframe and open the main application
frame.;
10 In the action listener for the reset password button, display a message that the
password has been reset.;
11 In the action listener for the create new account button, display a message that
the account has been created.;
12 Add the user interface components to the frame.;
13 End ;

2.2.3 Frame1.class

package handlersys;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;

public class frame1 extends JFrame implements ActionListener {

private ImageIcon icon;

private Container C;
private JPanel pane1;
//private JLabel userlabel1, userlabel2, userlabel3;

8
private JLabel titleLabel, NameLabel, productlabel, pricelabel, idlabel;
private JTextField nametf, pricetf, idtf, producttf;
private JButton addButton, deleteButton, clearButton, updateButton, SaveButton;
private Font h1f, h2f;
private JTable table;
private JScrollPane scroll;
private DefaultTableModel model;
private String[] columns = {"Name", "Product", "Price", "Id"};
private String[] rows = new String[4];

frame1() { // constructor
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(780, 690);
this.setTitle("Money Handler System (BETA)");
this.setResizable(false);
this.setLocationRelativeTo(null);
initComponents2();
}

public void initComponents2() {

C = getContentPane(); // Asigning content frame to C which is a object.
C.setLayout(null); // setting to null because of manually setting the object in
the frame
C.setBackground(Color.DARK_GRAY); // set content frame background color

h2f = new Font("Arial", Font.BOLD, 18); // creating font name,type,size

h1f = new Font("Arial", Font.BOLD, 24);

// creating img,icon object

icon = new ImageIcon(getClass().getResource("app_icon.png")); // import icon ,
IMAGE

this.setIconImage(icon.getImage()); // set icon to the app

titleLabel = new JLabel("Money handler System");

titleLabel.setFont(h1f);
titleLabel.setBounds(140, 10, 400, 50); //done
titleLabel.setForeground(Color.WHITE);
C.add(titleLabel);

NameLabel = new JLabel(" Name");

NameLabel.setBounds(10 + 40, 80, 140, 30);
NameLabel.setFont(h2f);
NameLabel.setForeground(Color.WHITE);
C.add(NameLabel);

nametf = new JTextField();

nametf.setBounds(110 + 25, 80, 200, 30);
nametf.setFont(h2f);
C.add(nametf);

productlabel = new JLabel("Product");

productlabel.setBounds(10 + 40, 130, 140, 30);
productlabel.setFont(h2f);
productlabel.setForeground(Color.WHITE);
C.add(productlabel);

producttf = new JTextField();

producttf.setBounds(110 + 25, 130, 200, 30);
producttf.setFont(h2f);
C.add(producttf);

9
pricelabel = new JLabel(" Price");
pricelabel.setBounds(10 + 40, 180, 140, 30);
pricelabel.setFont(h2f);
pricelabel.setForeground(Color.WHITE);
C.add(pricelabel);

pricetf = new JTextField();

pricetf.setBounds(110 + 25, 180, 200, 30);
pricetf.setFont(h2f);
C.add(pricetf);

idlabel = new JLabel(" ID");

idlabel.setBounds(10 + 40, 230, 140, 30);
idlabel.setFont(h2f);
idlabel.setForeground(Color.WHITE);
C.add(idlabel);

idtf = new JTextField();

idtf.setBounds(110 + 25, 230, 200, 30);
idtf.setFont(h2f);
C.add(idtf);

addButton = new JButton("Add");

addButton.setBounds(400, 80, 100, 30);
addButton.setFont(h2f);
C.add(addButton);

deleteButton = new JButton("Delete");

deleteButton.setBounds(400, 130, 100, 30);
deleteButton.setFont(h2f);
C.add(deleteButton);

clearButton = new JButton("Clear");

clearButton.setBounds(400, 180, 100, 30);
clearButton.setFont(h2f);
C.add(clearButton);

updateButton = new JButton("Update");

updateButton.setBounds(400, 230, 100, 30);
updateButton.setFont(h2f);
C.add(updateButton);

SaveButton = new JButton("SAVE");

SaveButton.setBounds(320, 300, 100, 30);
SaveButton.setFont(h2f);
C.add(SaveButton);

table = new JTable();

model = new DefaultTableModel();

model.setColumnIdentifiers(columns);
table.setModel(model);
table.setFont(h2f);
table.setSelectionBackground(Color.GRAY);
table.setBackground(Color.WHITE);
table.setRowHeight(30);
scroll = new JScrollPane(table);
scroll.setBounds(10, 360, 740, 265);
C.add(scroll);

Connection connection = null;

Statement statement = null;

10
ResultSet resultSet = null;

try {
// Register JDBC driver
Class.forName("com.mysql.cj.jdbc.Driver");

// Open connection
String dbUrl = "jdbc:mysql://localhost/moneydb";
String dbUser = "root";
String dbPass = "";
connection = DriverManager.getConnection(dbUrl, dbUser, dbPass);

System.out.println("Connected to database successfully!");

// Execute a query
String sql = "SELECT * FROM ‘moneytable‘";
statement = connection.createStatement();
resultSet = statement.executeQuery(sql);

// Extract data from result set

while (resultSet.next()) {
String name = resultSet.getString("Name");
String product = resultSet.getString("Product");
int price = resultSet.getInt("Price");
String id = resultSet.getString("ID");

rows[0] = name;
rows[1] = product;
rows[2] = Integer.toString(price);
rows[3] = id;
model.addRow(rows);

//System.out.println("Name: " + name + ", Product: " + product+" Price:

"+price+" ID: " +id);
}

} catch (ClassNotFoundException | SQLException e) {

System.out.println("Error: " + e.getMessage());
} finally {
try {
if (resultSet != null) {
resultSet.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
System.out.println("Connection closed successfully!");
}
} catch (SQLException e) {
System.out.println("Error closing resources: " + e.getMessage());
}
}

addButton.addActionListener(this);
deleteButton.addActionListener(this);
updateButton.addActionListener(this);
clearButton.addActionListener(this);
SaveButton.addActionListener(this);
table.addMouseListener(
new MouseAdapter() {

11
 public void mouseClicked(MouseEvent e) {
int numberofrow = table.getSelectedRow();
String nameString = model.getValueAt(numberofrow, 0).toString();
String producString = model.getValueAt(numberofrow, 1).toString();
String priceString = model.getValueAt(numberofrow, 2).toString();
String idString = model.getValueAt(numberofrow, 3).toString();

nametf.setText(nameString);
producttf.setText(producString);
pricetf.setText(priceString);
idtf.setText(idString);
}
}
);
}

@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == addButton) {
rows[0] = nametf.getText();
rows[1] = producttf.getText();
rows[2] = pricetf.getText();
rows[3] = idtf.getText();
model.addRow(rows);
} else if (e.getSource() == SaveButton) {

System.out.println("Save Button Clicked");

try {
JTableSync.replaceTable(table);
JOptionPane.showMessageDialog(null, "Saved Successful!!");

} catch (SQLException ex) {

JOptionPane.showMessageDialog(null, "Save Unsuccessful!");

}
} else if (e.getSource() == clearButton) {
nametf.setText("");
producttf.setText("");
pricetf.setText("");
idtf.setText("");
} else if (e.getSource() == deleteButton) {
int numberofrow = table.getSelectedRow();
if (numberofrow >= 0) {
model.removeRow(numberofrow);
} else {
JOptionPane.showMessageDialog(null, "You didn’t selected anything!");
}
} else if (e.getSource() == updateButton) {
int numberOfrow = table.getSelectedRow();

String namString = nametf.getText();

String prodString = producttf.getText();
String pricString = pricetf.getText();
String idString = idtf.getText();

model.setValueAt(namString, numberOfrow, 0);

model.setValueAt(prodString, numberOfrow, 1);
model.setValueAt(pricString, numberOfrow, 2);
model.setValueAt(idString, numberOfrow, 3);
}
}

12
 public class JTableSync {

private static final String DB_URL = "jdbc:mysql://localhost/moneydb";

private static final String DB_USER = "root";
private static final String DB_PASSWORD = "";
private static final String TABLE_NAME = "moneytable";
private static final String[] COLUMN_NAMES = {"Name", "Product", "Price", "ID"};

public static void replaceTable(JTable table) throws SQLException {

DefaultTableModel model = (DefaultTableModel) table.getModel();

try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER,

DB_PASSWORD)) {
// Truncate the table to remove all existing data
String truncateQuery = "TRUNCATE TABLE " + TABLE_NAME;
try (PreparedStatement truncateStatement =
conn.prepareStatement(truncateQuery)) {
truncateStatement.executeUpdate();
}

// Insert the new data from the JTable into the table
String insertQuery = "INSERT INTO " + TABLE_NAME + " (Name, Product,
Price, ID) VALUES (?, ?, ?, ?)";
try (PreparedStatement insertStatement =
conn.prepareStatement(insertQuery)) {
for (int i = 0; i < model.getRowCount(); i++) {
String name = model.getValueAt(i, 0).toString();
String product = model.getValueAt(i, 1).toString();
double price = Double.parseDouble(model.getValueAt(i,
2).toString());
String id = model.getValueAt(i, 3).toString();

insertStatement.setString(1, name);
insertStatement.setString(2, product);
insertStatement.setDouble(3, price);
insertStatement.setString(4, id);

insertStatement.executeUpdate();
}
}
}
}
}

public static void main(String[] args) {

frame1 frame = new frame1();
frame.setVisible(true);
}
}

2.2.4 Algorithm

13
 Algorithm 2: Search using thread
Input: N
Result: Found by Thread No: ” index id”. The index is ”index number”
1 Start ;
2 Import necessary libraries and packages.;
3 Create a class named frame1 that extends JFrame and implements
ActionListener.;
4 Define instance variables to hold GUI components such as labels, text fields,
buttons,;
5 and a table.;
6 Define a constructor for the frame1 class that sets various properties of the
frame, such as its size and title, and calls a method named initComponents2().;
7 Define a method named initComponents2() that creates the GUI components,
sets their properties, and adds them to the frame.;
8 Use a layout manager (in this case, null layout) to manually position the GUI
components within the frame.;
9 Define an action listener for the buttons that performs the desired database
operation (add, delete, clear, update).;
10 Create a JTable and a DefaultTableModel and set the latter as the model for
the former.;
11 Add the JTable to a JScrollPane and add the JScrollPane to the frame.;
12 Connect to a database using JDBC and perform desired database operations
(insert, delete, update, select) using SQL queries.;
13 Populate the JTable with data retrieved from the database.;
14 The code connects to a database using JDBC.;
15 The code executes a SELECT query to retrieve data from the database and
populates a JTable with the data.;
16 The code defines an event listener for various buttons (add, delete, update,
clear) that performs the desired database operation.;
17 When the Save button is clicked, the code uses JTableSync to replace the data
in the database table with the data in the JTable.;
18 JTableSync truncates the table and inserts the new data from the JTable into
the table. The code defines a class named frame1 that extends JFrame and
implements ActionListener. The code defines instance variables to hold GUI
components such as labels, text fields, buttons, and a table.;
19 The code defines a constructor for the frame1 class that sets various properties
of the frame, such as its size and title, and calls a method named
initComponents2().;
20 The code defines a method named initComponents2() that creates the GUI
components, sets their properties, and adds them to the frame.;
21 The code uses a layout manager (in this case, null layout) to manually position
the GUI components within the frame.;
22 The code defines an action listener for the table that sets the text fields to the
values of the selected row when the row is clicked.;
23 The code defines an actionPerformed() method that performs the desired
database operation when a button is clicked.;
24 The code defines a JTableSync class that replaces the data in the database table
with the data in the JTable.;
25 End ;

14
Chapter 3

Interface Snapshots

3.1 LogIn page

Figure 3.1: Simple Login Page

The login page is an important security feature that ensures the safety and privacy
of user data within the system. prompts users to enter their username and password,
which are authenticated against a database of authorized users.

3.2 Frame
The frame is the main user interface component that provides a graphical user interface
for the Money Handler System. The frame contains various GUI components such as
labels, text fields, buttons, and a table, which allow users to interact with the system and
manage financial transactions. The frame is implemented as a class named ”frame1”
that extends the JFrame class and implements the ActionListener interface to respond
to user actions.

15
 The frame provides a window that displays the system’s functionality, and the user
can interact with the system through the GUI components on the frame. The frame al-
lows the user to add, delete, update, and clear financial transactions, and these actions
are performed by event listeners that respond to user actions on the GUI components.
Additionally, the frame is designed using a layout manager that allows the GUI com-
ponents to be positioned and arranged within the frame. [6]

Figure 3.2: First FRAME overlook

3.3 SQL
SQL (Structured Query Language) is used to manage the database that stores the
financial records for the Money Handler System. SQL is a standard language for man-
aging relational databases and is commonly used for data manipulation, retrieval, and
management.
The SQL database is used to store and manage financial transaction records, includ-
ing information such as the product name, date of purchase, price, and other related
details. The SQL database allows the system to store and manage a large volume of
financial records efficiently and securely.

16
 The SQL database is accessed through Java Database Connectivity (JDBC), which
provides the ability to connect to and interact with the database from within the Java
application. The JDBC API allows Java applications to send SQL statements to the
database and retrieve data for processing within the application. [2]

Figure 3.3: Data Base table: moneytable

17
Chapter 4

Conclusion

4.1 Introduction
The Money Handler System is an innovative application that simplifies the task of
managing financial records. The system is designed to allow users to add, delete, and
update financial transactions in real-time. The project is developed using Java Swing
and MySQL database, which makes it easy to use and interact with. The system
includes a login page and a frame that collects and sends information to the server.
The application is user-friendly and efficient, making it an ideal solution for financial
management tasks.

4.2 Practical Implications

There are several areas where the Money Handler System can be improved and ex-
panded upon in the future. Some of the potential areas for future work include:
• Adding more advanced features such as data analysis and reporting.
• Integrating with other financial management systems.
• Incorporating more advanced security features to protect user data.
• Enhancing the user interface to make it more intuitive and user-friendly.
• Enhancing Adding multi-language support to make the application more accessible
to non-English speakers.
[3]

4.3 Scope of Future Work

The Money Handler System has several practical implications for users who need to
manage financial records. The system provides an easy and efficient way to track
financial transactions, which can help users make better financial decisions. The system
can be used by individuals, small businesses, and organizations to manage their financial
records more effectively. The system is user-friendly and easy to use, which makes it
accessible to a wide range of users. Overall, the Money Handler System has the potential
to improve financial management practices and save time for users.

18
 In conclusion, the Money Handler System is an effective solution for managing finan-
cial records with ease and efficiency. The system’s user-friendly interface and advanced
features make it an ideal choice for individuals, small businesses, and organizations.
With the potential for future expansion and improvement, the Money Handler System
offers practical implications that can help users make better financial decisions. This
project has highlighted the benefits of using Java and MySQL databases in develop-
ing such systems. As such, the Money Handler System is a valuable tool for financial
management that can save time and improve financial record keeping.

19
Bibliography

[1] Anisul Islam. Java Swing Tutorial. https://www.youtube.com/watch?

v=28P_QSR-ouQ&list=PLgH5QX0i9K3rAHKr6IteF5kdgN6BorH9l&ab_channel=
AnisulIslam, Accessed 2023.
[2] IBM. Introduction to SQL. https://www.ibm.com/cloud/learn/sql, Accessed
2023.
[3] Oracle Corporation. Java Swing Documentation. https://docs.oracle.com/
javase/tutorial/uiswing/, Accessed 2023.
[4] Oracle Corporation. JDBC Documentation. https://docs.oracle.com/javase/
8/docs/api/java/sql/package-summary.html, Accessed 2023.
[5] Oracle Corporation. MySQL Documentation. https://dev.mysql.com/doc/, Ac-
cessed 2023.
[6] Oracle Corporation. Why use JDBC? https://www.oracle.com/
technical-resources/articles/javase/jdbc.html, Accessed 2023.

20