A Project Report
on
PERSONAL FINANCE MANAGEMENT SYSTEM.
Submitted in partial fulfillment of requirements for the award of the course
of
CGB1201 – JAVA PROGRAMMING
Under the guidance of
Mrs.S.BHARANI NAYAGI M.E.,Ph.d
Assistant Professor / AI
Submitted By
P.AJISHMA SRUTHI(927623BAM003)
DEPARTMENT OF ARTIFICIAL INTELLIGENCE AND MACHINE
LEARNING
M.KUMARASAMY COLLEGE OF ENGINEERING
(Autonomous)
KARUR – 639 113
DECEMBER 2024
M. KUMARASAMY COLLEGE OF ENGINEERING
(Autonomous Institution affiliated to Anna University, Chennai)
KARUR – 639 113
BONAFIDE CERTIFICATE
Certified that this project report on “PERSONAL FINANCE
MANAGEMENT SYSTEM” is the bonafide work of P.AJISHMA
SRUTHI(927623BAM003) who carried out the project work during the
academic year 2024 - 2025 under my supervision.
Signature Signature
Mrs. S.BHARANI NAYAGI M.E.,Ph.d Dr. A.SELVI M.E.,Ph.D.,
SUPERVISOR, HEAD OF THE DEPARTMENT,
Department of artificial intelligence and Department of Artificial intelligence and
machine learning, machine learning,
M.Kumarasamy College of Engineering, M.Kumarasamy College of Engineering,
Thalavapalayam, Karur -639 113. Thalavapalayam, Karur -639 113.
ii
DEPARTMENT OF ARTIFICIAL INTELLIGENCE AND MACHINE
LEARNING
VISION OF THE INSTITUTION
To emerge as a leader among the top institutions in the field of technical
education
MISSION OF THE INSTITUTION
Produce smart technocrats with empirical knowledge who can surmount the
global challenges
Create a diverse, fully-engaged, learner-centric campus environment to provide
quality education to the students
Maintain mutually beneficial partnerships with our alumni, industry, and
Professional associations
VISION OF THE DEPARTMENT
To achieve education and research excellence in Computer Science and
Engineering
MISSION OF THE DEPARTMENT
To excel in academic through effective teaching learning techniques
To promote research in the area of computer science and engineering with the
focus on innovation
To transform students into technically competent professionals with societal and
ethical responsibilities
PROGRAM EDUCATIONAL OBJECTIVES (PEOS)
PEO 1:Graduates will have successful career in software industries and R&D
divisions through continuous learning.
PEO 2: Graduates will provide effective solutions for real world problems in the
key domain of computer science and engineering and engage in lifelong learning.
PEO 3: Graduates will excel in their profession by being ethically and socially
responsible.
PROGRAM OUTCOMES
Engineering students will be able to:
1. Engineering knowledge: Apply the knowledge of mathematics, science,
engineering fundamentals, and an engineering specialization to the solution of
complex engineering problems.
2. Problem analysis: Identify, formulate, review research literature, and analyze
complex engineering problems reaching substantiated conclusions using first
principles of mathematics, natural sciences, and engineering sciences.
3. Design/development of solutions: Design solutions for complex engineering
problems and design system components or processes that meet the specified
needs with appropriate consideration for the public health and safety, and the
cultural, societal, and environmental considerations.
4. Conduct investigations of complex problems: Use research-based knowledge
and research methods including design of experiments, analysis and
interpretation of data, and synthesis of the information to provide valid
conclusions.
5. Modern tool usage: Create, select, and apply appropriate techniques, resources,
and modern engineering and IT tools including prediction and modeling to
complex engineering activities with an understanding of the limitations.
6. The engineer and society: Apply reasoning informed by the contextual
knowledge to assess societal, health, safety, legal and cultural issues and the
consequent responsibilities relevant to the professional engineering practice.
7. Environment and sustainability: Understand the impact of the professional
engineering solutions in societal and environmental contexts, and demonstrate
the knowledge of, and need for sustainable development.
8. Ethics: Apply ethical principles and commit to professional ethics and
responsibilities and norms of the engineering practice.
9. Individual and team work: Function effectively as an individual, and as a
member or leader in diverse teams, and in multidisciplinary settings.
10.Communication: Communicate effectively on complex engineering activities
with the engineering community and with society at large, such as, being able to
comprehend and write effective reports and design documentation, make
effective presentations, and give and receive clear instructions.
11.Project management and finance: Demonstrate knowledge and understanding
of the engineering and management principles and apply these to one’s own
work, as a member and leader in a team, to manage projects and in
multidisciplinary environments.
12.Life-long learning: Recognize the need for, and have the preparation and
ability to engage in independent and life-long learning in the broadest context of
technological change.
PROGRAM SPECIFIC OUTCOMES (PSOs)
PSO1: Professional Skills: Ability to apply the knowledge of computing
techniques to design and develop computerized solutions for the problems.
PSO2: Successful career: Ability to utilize the computing skills and ethical
values in creating a successful career.
ABSTRACT
The Digital Notice Board System is a Java-based application designed to
replace traditional physical notice boards with a digital solution that offers
dynamic, efficient notice management. The system allows authorized
users to post, update, delete, and view notices through a secure interface.
Implementing roles such as Admin, Editor, and Viewer ensures controlled
access to various functions, enhancing security and usability. Key features
include user authentication, real-time updates, and the ability to view
specific notices by title. This project improves information dissemination
in institutions, workplaces, and community settings, providing an
accessible and modern solution for organizational communication.
ABSTRACT WITH POs AND PSOs MAPPING
PSOs
ABSTRACT POs MAPPED
MAPPED
A personal finance management system is a PO1(3) PSO1(1)
software application designed to help individuals PO2(3)
PSO2(2)
PO3(3)
track, manage, and plan their financial activities.
PO4(2)
This system allows users to record income, PO5(3)
expenses, and savings, providing insightful reports PO6(2)
and data visualizations for informed decision- PO7(2)
making. Developed using Java as the front-end PO8(1)
programming language, this system ensures a user- PO9(2)
PO10(2)
friendly interface while integrating key features such
PO10(3)
as budget tracking, transaction categorization, and PO11(2)
financial goal-setting. The primary aim is to simplify PO12(2)
financial planning and enhance user financial
literacy.
Note: 1- Low, 2-Medium, 3- High
SUPERVISOR HEAD OF THE DEPARTMENT
vii
TABLE OF CONTENTS
CHAPTER TITLE PAGE
No. No.
ABSTRACT
1 INTRODUCTION 1
1.1 Objective 1
1.2 Overview 1
1.3 Java Programming concepts 2
2 PROJECT METHODOLOGY
2.1Proposed Work
2.2 Block Diagram
3 MODULE DESCRIPTION
3.1 INCOME TRACKING MODULE
3.2 EXPENSE TRACKING MODULE
3.3 BUDGET TRACKING MODULE
4 RESULTS AND DISCUSSION
5 CONCLUSION
REFERENCES
APPENDIX
viii
CHAPTER 1
INTRODUCTION
1.1 Objective
The primary objective of the personal finance management system is to provide
individuals with a comprehensive and intuitive platform to take control of their
financial activities. The system aims to achieve the following goals:
Streamline Financial Tracking: Enable users to easily record and categorize
their income and expenses, ensuring an organized view of their financial
transactions.
Promote Budgeting Discipline: Help users set realistic budgets for different
spending categories and provide tools to monitor adherence to these
budgets, encouraging disciplined financial habits.
Improve Financial Decision-Making: Offer insightful visualizations such
as charts, graphs, and trends to help users understand their spending
patterns and make informed financial decisions.
Ensure Data Privacy and Security: Implement basic authentication
measures to protect user data, fostering trust and confidence in the system.
By addressing these objectives, the system seeks to become a valuable tool for
users looking to achieve financial stability and long-term financial success.
1.2 Overview
The personal finance management system uses Java to create a responsive and
intuitive graphical user interface (GUI). Key functionalities include:
Income and Expense Tracking: Users can log transactions and categorize
them for better clarity.
1
Budget Management: Monthly or custom budgets can be set and monitored.
Data Visualization: Pie charts, bar graphs, and trend lines help users analyze
spending patterns.
Reports: Periodic financial summaries are generated for better understanding
and decision-making.
Security: Basic authentication ensures data privacy.
The system is designed with modular architecture, ensuring scalability and
maintainability, and can be extended to integrate with external financial tools
or services.
1.3 Java Programming Concepts
Encapsulation: Bundles financial data with methods to securely
manage it.
Inheritance: Creates specialized account classes to reuse code and
add features.
Polymorphism: Handles different account types with a common
method for flexibility.
Exception Handling: Manages errors (e.g., overdrawing) to
prevent crashes and ensure data integrity
1
CHAPTER 2
PROJECT METHODOLOGY
2.1Proposed Work
1.Start: The system initializes and loads any previous financial data.
2.Main Menu: The user is presented with a set of options like
• adding income
• adding expenses.
• viewing the balance.
• setting budgets.
3.Add Income: User enters an amount for income, and the system updates the
balance and records the transaction
4. Add Expense: User enters an amount and category for an expense, and the
system updates the balance and records the transaction.
5.View Balance: The user can view their current balance.
6.Set Budget: The user can define budgets for specific categories, and the system
records and saves this information.
7.View Spending Report: The user can generate and view a report of all their
transactions.
8.Exit: The system saves data to a file and exits
1
2.2 Block Diagram
1
CHAPTER 3
MODULE DESCRIPTION
3.1 INCOME TRACKING MODULE
Purpose:
This module enables users to document and organize their income sources,
providing a clear view of their earnings and ensuring accurate financial
planning.
Functionality:
Record and categorize income from various sources,view a summary of
total income over specified time periods.
Compare income against expenses to calculate savings,generate income
reports for better financial analysis.
Support recurring income entries (e.g., monthly salary)
Available Choose
Start Login Option Income
Fill Income
details
3.2 EXPENSE TRACKING MODULE
Purpose:
The purpose of this module is to help users monitor and record their spending
13
habits, categorize expenses, and identify areas where they can reduce unnecessary
expenditures.
Functionality:
Add, edit, and delete expense records.Categorize expenses (e.g., food,
transportation, utilities).
View detailed expense reports by category or time period.
Generate visualizations such as pie charts or graphs to analyze spending
patterns.
Set notifications for high spending in specific categories.
Login Add
Start Submit
Expense
Details
3.3 BUDGET TRACKING MODULE
Purpose:
The budget tracking module is designed to assist users in creating and managing
budgets, helping them maintain financial discipline and achieve their financial
goals.
Functionality:
Create custom budgets for specific categories,monitor actual spending versus
budgeted amounts.
14
Provide alerts when spending nears or exceeds the set budget,offer
recommendations based on historical spending data.
Generate periodic reports showing adherence to budgets.
Start
Login/Sign Up
Create/monitor spending plan
Is the Spending
within Budget?
Continue
RRe-evaluate
Exit
15
CHAPTER 4
RESULTS AND DISCUSSION
USER LOGIN:
888
17
18
CHAPTER 5
CONCLUSION
The personal finance management system developed in Java provides an accessible
and efficient way to manage personal finances. By combining user-friendly features
with robust functionality, the system empowers users to gain better control over their
financial health. This tool not only aids in day-to-day financial tracking but also
helps users develop habits conducive to long-term financial success. With further
enhancements, such as mobile app integration and AI-based financial advice, the
system has the potential to become a comprehensive financial assistant.
19
REFERENCES:
1.JavaTpoint
https://www.javatpoint.com/
2.GeeksforGeeks
https://www.geeksforgeeks.org
3.ChatGPT by OpenAI
https://chat.openai.com/
20
APPENDIX
(Coding)
package personalfinance;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class PersonalFinanceManagerGUI {
// List to hold financial transactions
private static List<Transaction> transactions = new ArrayList<>();
private static Map<String, Double> spendingLimits = new HashMap<>();
private static JTextArea summaryArea;
private static Map<String, Double> categorySpending = new HashMap<>();
public static void main(String[] args) {
// Show the password prompt first
showPasswordPrompt();
}
private static void showPasswordPrompt() {
// Password dialog setup
JPasswordField passwordField = new JPasswordField(20);
JPanel panel = new JPanel();
panel.add(new JLabel("Enter password:"));
panel.add(passwordField);
// Show the dialog
int option = JOptionPane.showConfirmDialog(null, panel, "Password
Required", JOptionPane.OK_CANCEL_OPTION,
JOptionPane.PLAIN_MESSAGE);
// Check if the user pressed OK and if the password is correct
if (option == JOptionPane.OK_OPTION) {
String enteredPassword = new String(passwordField.getPassword());
21
// Define your password (you can change this to a more secure method)
String correctPassword = "mysecurepassword"; // Example password
if (enteredPassword.equals(correctPassword)) {
// If password is correct, open the main finance window
openMainFinanceWindow();
} else {
// If password is incorrect, show an error and exit
JOptionPane.showMessageDialog(null, "Incorrect password. Exiting...");
System.exit(0);
}
} else {
// If the user cancels the password entry, exit the program
System.exit(0);
}
}
private static void openMainFinanceWindow() {
// Set up the main frame
JFrame frame = new JFrame("Personal Finance Management");
frame.setSize(600, 400);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(new BorderLayout());
// Create a panel for the transaction inputs
JPanel inputPanel = new JPanel();
inputPanel.setLayout(new GridLayout(6, 2));
// Transaction Category (Income, Expense, Savings, Investment)
JComboBox<String> categoryComboBox = new JComboBox<>(new String[]
{"Income", "Expense", "Savings", "Investment"});
inputPanel.add(new JLabel("Category:"));
inputPanel.add(categoryComboBox);
// Amount Input
JTextField amountField = new JTextField();
inputPanel.add(new JLabel("Amount:"));
inputPanel.add(amountField);
// Description Input
JTextField descriptionField = new JTextField();
inputPanel.add(new JLabel("Description:"));
22
inputPanel.add(descriptionField);
// Date Input
JTextField dateField = new JTextField();
dateField.setText("2024-11-21"); // default date for simplicity
inputPanel.add(new JLabel("Date:"));
inputPanel.add(dateField);
// Spending Limit Input
JTextField spendingLimitField = new JTextField();
inputPanel.add(new JLabel("Set Spending Limit (Optional):"));
inputPanel.add(spendingLimitField);
// Add button to save transaction
JButton addButton = new JButton("Add Transaction");
inputPanel.add(addButton);
// Summary Area (to display total income, expenses, etc.)
summaryArea = new JTextArea();
summaryArea.setEditable(false);
summaryArea.setText("Financial Summary:\n\nTotal Income: $0.0\nTotal
Expenses: $0.0\nBalance: $0.0");
// Table for displaying transactions
String[] columns = {"Category", "Amount", "Description", "Date"};
JTable transactionTable = new JTable(new Object[0][4], columns);
JScrollPane tableScrollPane = new JScrollPane(transactionTable);
// Add components to the frame
frame.add(inputPanel, BorderLayout.NORTH);
frame.add(new JScrollPane(transactionTable), BorderLayout.CENTER);
frame.add(summaryArea, BorderLayout.SOUTH);
// Action Listener for the Add Button
addButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String category = categoryComboBox.getSelectedItem().toString();
String amountText = amountField.getText();
String description = descriptionField.getText();
String date = dateField.getText();
String spendingLimitText = spendingLimitField.getText();
23
try {
double amount = Double.parseDouble(amountText);
// Create a new transaction and add it to the list
Transaction transaction = new Transaction(category, amount,
description, date);
transactions.add(transaction);
// If a spending limit is set for this category, store it
if (!spendingLimitText.isEmpty()) {
double spendingLimit = Double.parseDouble(spendingLimitText);
spendingLimits.put(category, spendingLimit);
}
// Update the summary
updateSummary();
// Track the spending for the category
categorySpending.put(category,
categorySpending.getOrDefault(category, 0.0) + amount);
// Check if the spending exceeds the limit
if (spendingLimits.containsKey(category) &&
categorySpending.get(category) > spendingLimits.get(category)) {
JOptionPane.showMessageDialog(frame, "Alert: You have exceeded
your spending limit for this category!", "Spending Limit Alert",
JOptionPane.WARNING_MESSAGE);
}
// Clear input fields
amountField.setText("");
descriptionField.setText("");
dateField.setText("2024-11-21");
spendingLimitField.setText("");
// Refresh the table
updateTransactionTable(transactionTable);
} catch (NumberFormatException ex) {
JOptionPane.showMessageDialog(frame, "Invalid amount. Please enter
a valid number.");
}
}
});
24
// Finalize the window
frame.setVisible(true);
}
// Method to update the financial summary
private static void updateSummary() {
double totalIncome = 0;
double totalExpenses = 0;
for (Transaction t : transactions) {
if (t.getCategory().equals("Income")) {
totalIncome += t.getAmount();
} else if (t.getCategory().equals("Expense")) {
totalExpenses += t.getAmount();
}
}
double balance = totalIncome - totalExpenses;
summaryArea.setText("Financial Summary:\n\n" +
"Total Income: $" + totalIncome + "\n" +
"Total Expenses: $" + totalExpenses + "\n" +
"Balance: $" + balance);
}
// Method to update the transaction table
private static void updateTransactionTable(JTable table) {
Object[][] data = new Object[transactions.size()][4];
for (int i = 0; i < transactions.size(); i++) {
Transaction t = transactions.get(i);
data[i][0] = t.getCategory();
data[i][1] = t.getAmount();
data[i][2] = t.getDescription();
data[i][3] = t.getDate();
}
table.setModel(new javax.swing.table.DefaultTableModel(data, new String[]
{"Category", "Amount", "Description", "Date"}));
}
// Simple Transaction class to hold the data
25
static class Transaction {
private String category;
private double amount;
private String description;
private String date;
public Transaction(String category, double amount, String description, String
date) {
this.category = category;
this.amount = amount;
this.description = description;
this.date = date;
}
public String getCategory() {
return category;
}
public double getAmount() {
return amount;
}
public String getDescription() {
return description;
}
public String getDate() {
return date;
}
}
}
26
