Banking Software Project: Design, Implementation, and Evaluation

This project details the design and implementation of a banking software system. It begins with a Use Case Model Diagram to illustrate different actors and their actions within the system, followed by a Class Diagram that represents the classes, their attributes, and relationships. A Sequence Diagram is then presented to depict the chronological order of interactions between objects. The project includes the Java code for the software, which incorporates classes for bank accounts, bank tellers, and bank managers, along with exception handling for insufficient funds. The critical discussion section provides a self-reflection on the work, discussing the Software Development Life Cycle (SDLC) phases, including requirement gathering, design, development, software testing, and deployment, as well as addressing any issues encountered and concluding with a summary of the project's achievements.

1

Contents
1.Use Case Model Diagram (Logical Design Diagram)..................................................................4
2.Class Diagram (Logical Design)..................................................................................................6
3.Sequence Diagram (Logical Design)............................................................................................8
4. Program........................................................................................................................................9
Critical Discussion: Introduction...................................................................................................18
NationNarrow Reflection and Critical-Evaluation....................................................................18
Critical self-reflection on the work................................................................................................19
Software Development Life Cycle (SDLC) of this software.....................................................19
Requirement Gathering..........................................................................................................19
Design.....................................................................................................................................19
Development..........................................................................................................................20
Software Testing.....................................................................................................................20
Deployment............................................................................................................................21
Feedback.................................................................................................................................22
Issues..............................................................................................................................................23
Conclusion.....................................................................................................................................23
References......................................................................................................................................24
2

Table of Content
S. NO. CONTENT PAGE NO.
1. Use Case Model Diagram 2
2. Class Diagram 4
3. Sequence Diagram 6
4. Program 8
5. Critical Discussion : Introduction 16
6. Critical self-reflection on the work 17
7. Issues 21
8. Conclusion 21
9. References 22
3

1. Use Case Model Diagram (Logical Design Diagram)
This diagram is employed to characterizedifferent actors / users or clients and their
operations or actions or events.This use case diagram is employed to model the structure of
software or a sub system. It highlights the representation of user and their actions in which
the particular user or an actor or a client is working on. It has mainly 2 components one is
actor and two is use case in a specific application.It specifies theusers who are all going to
use particular software without minding the actual implementation of a function. The actors
are the real end users of the software which is depicted using an actor stereotype. The use
case action is specified using oval symbol(Baysal, 2016). It is to be named with an action
verb for functionality. The relationship between actor and a use case symbol is depicted
through a line which linkages the both. In this Banking Software for NatioNarrow Building
Society 3 main use cases where defined. They are
o Bank Manager,
o Bank Teller and Customer.
4

Bank Software - Use Case Diagram Explanation
The following Bank Software Use Case diagram is a diagrammatic representation of
different use cases or actors or users of this particular software. E.g. the bank teller may be one
actor, customer is another actor and bank manager is a one more actor of this software. The bank
teller actor performs actions such as balance enquiry, cash deposit, cash withdrawal and fund
transfer operations in this bank software and he also performs reversing a transaction. Like bank
teller actor, customer actor also performs operations like balance update enquiry, deposit,
withdrawal and transfer operations in this bank software and also request bank statements made
between dates and requesting to show all transactions of an account. The bank manager actor
performing operation includes user credential and loan approval and sanctioning along with
balance enquiry, cash deposit, cash withdrawal and fund transfer operations in this bank
software(Felipe P. Vista IV 1, 2013).
5

6

2. Class Diagram (Logical Design)
This diagram is used to represent classes along with its attributes (variables) and methods
(operations) also it is employed to specify relationship among base and derived classes.It is a
logical building of a software program.It provides the complete structure of an object oriented
programming software application. It is an actual depiction of various class usages in software. It
is employed only for object oriented constructs(Nunes, 2018). The group of all the class
depictions forms a class diagram. The class representation box first part should have proper class
name along with the attribute depiction box second part should have the names of a variable and
the method denoting box third part should have the name and return type of the function name.
It is decisively for stagnant depiction of a system. It will be sketched for the languages like c++,
java, php, python, Smalltalk,etc.,
7

Bank- Software - Class Diagram Explanation
In the following Bank software class diagram it is represented with many classes and its
mutual relationship existing among those classes. The class diagram has totally seven classes,
out of seven classes; two classes are built in classes imported from a java packages and the
remaining five classes are user defined classes.The classes are user defined required classes in
the Bank Software. The Bank Account classes are used to perform main bank operations
including debit and credit which is inherited by the class branch. The branch class is added with
the function addAccount() along with the base class bankproperties which is again inherited by
the classbranch which supports functionality like getloan() along with the properties of its base
classbranch.
The user defined classsavings_Account,current_Accountis inherited from the built in
class.The one more user defined class customer is inherited from the built in class r which
support for handling customer information(Pathak, 2017).
8

9

Sequence Diagram (Logical Design)
It illustrates dealings among objects in a chronological order.It is also termed as event
diagram or event scenarios. It showcases when oneobject finishes it operations and when another
begins its work. It is for the depiction of factual time state of affairs. It shows the manner how a
system is moving on while it’s functioning. The symbols employed to draw basically the
sequence diagram involves an actor, life lines, messages, etc., The Actor is an external entity
which is employed to play a role on a system functioning.It is placed at the top of the line .Any
number of actors can be involved in a scenario depending upon the system. Each instance of a
class is depicted as a life line which is also placed at the top of a line. It is a name represented
component of a sequence diagram(R S Madanayake1, 2017). The life line is an internal
component of a sequence diagram.
The messages are depicted using an arrow line which shows the contact between objects or
among an instance of a class or an object. Messages and lifeline are the vital components for the
depiction of a sequence diagram. In the below diagram Bank actor is involved along with the life
lines which has an instance of the classes AccountCreationbranch and Loan.
10

Banking Software – Sequential Diagram Explanation
In the following Banking Software- sequential diagram is explored.It is a diagram which
shows the sequential actions flows in the banking software. In the diagram actor bank and
instances of classes are involved.
The actor is Bank which is involved along with the life lines which is actually an instance of
the classes existing in the Bank software which includes AccountCreation,branch and Loan.
Initially instance of BankAccount is activated toward the Account creation then it is
communicated towards the branchInstance followed by show details debitcredit messages are
communicated to the instance of a class branch. During debit in case of insufficient balance
exception is raised it is sent back to the actor Bank from the instance branch(Saleh, 2015).
11

12

4. Program
packagecom.shre.servicemgmt.service;
importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.*;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JOptionPane;
importjavax.swing.JPanel;
classBankTellerextendsJFrameimplementsActionListener // inherits JFrame
{
Labellab=newLabel(" "); // label creation lab
Labellab1=newLabel(" ");// label creation lab1
TextFieldt[]=newTextField [4]; // creation of 4 textbox
Labell[]=newLabel [4];// creation of 4 label
Buttonbut=newButton("Create Account"); // Button to create Account
Buttonbut1=newButton("Test Account"); // Button to test Account
Buttonshow = newButton ("Show Details");// Button to show details
Buttonbtnusercred = newButton ("User Credentials");// Button to User
Credentials
Buttonbtnloandet = newButton ("Loan Details");// Button to show Loan
Details
Buttontrans = newButton ("Transfer");// Button to User Credentials
Buttonshowdates = newButton (" Transaction between dates");//
JFramef=newJFrame("Bank Frame Creation"); // Frame Creation
BankAccountb; // object creation for BankAccount class
BankTeller() // 0 parameter constructor definition
{
addWindowListener(newNewWindowAdapter()); // adding WindowListener
setLayout(newGridLayout(3,0));// setting layout
Panelp=newPanel(); // creation of panel
Panelp1=newPanel(); // creation of panel
but.addActionListener(this); // adding button but to the ActionListener
but1.addActionListener(this); // adding button but1 to the ActionListener
13

show.addActionListener(this);// adding button show to the ActionListenr
Class
btnusercred.addActionListener(this); // adding button to the Listener
btnloandet.addActionListener(this); // adding button to the Listener
p.setLayout(newGridLayout(9,2)); // setting grid layout to the panel p
p1.add(lab1); // adding label to the panel
p1.add(lab); // adding label lab to the panel
l[0]=newLabel("Account Number");// Initializing label l[0]
l[1]=newLabel("Initial Balance");// Initializing labell[1]
l[2]=newLabel("Deposit Amount");// Initializing label l[2]
l[3]=newLabel("Withdraw Amount"); // Initializing label l[3]
for(inti=0;i<4;i++) // looping
{
t[i]=newTextField(10); // initializing text field
p.add(l[i]); //adding label in the panel
p.add(t[i]); //adding text box in the panel
}
p.add(but); // adding button but in the panel
p.add(but1); // adding button but 1 in the panel
p.add(show); // adding button show in the panel
p.add(btnusercred); // adding button btnusercred in the panel
p.add(btnloandet); // adding button btnloandet in the panel
but1.setVisible(false); // setting visibility false for but1
l[2].setVisible(false); // setting visibility false for l[2]
l[3].setVisible(false); // setting visibility false for l[3]
t[2].setVisible(false); // setting visibility false for t[2]
t[3].setVisible(false); // setting visibility false for t[3]
add(p);
add(p1);
}
StringtestAccount(intd_amt,intw_amt)
{
Stringmsg="";
b.deposit(d_amt); // calling deposit method
System.out.println("d_amt"+d_amt);
JOptionPane.showMessageDialog(frame, "Transaction Succesful!"); //
Raising Alert
//msg="Transaction Succesful";
14

/*
try
{
b.withdraw(w_amt);
}catch(FundsInsufficientExceptionfe)
{
fe=new FundsInsufficientException(b.amount,w_amt);
msg=String.valueOf(fe);
}*/
returnmsg;
}
publicvoidactionPerformed(ActionEventae) // invoked when mouse click is
in action
{
Stringstr=ae.getActionCommand(); // calling action command
if(str.equals("Create Account")) // checking create account
{
b
=newBankAccount(Integer.parseInt(t[0].getText()),Integer.parseInt(t[1].ge
tText()));
but1.setVisible(true);
show.setVisible(true);// setting visibility for the buttons show
l[2].setVisible(true);// setting visibility for the label l[2]
l[3].setVisible(true); // setting visibility for the label l[3]
t[2].setVisible(true); // setting visibility for the text box t[2]
t[3].setVisible(true);// setting visibility for the text box t[3]
but.setVisible(false); // setting visibility for the button but
l[0].setVisible(false); // setting visibility for the label l[0]
l[1].setVisible(false); // setting visibility for the label l[1]
t[0].setVisible(false); // setting visibility for the text box t[0]
t[1].setVisible(false); // setting visibility for the text box t[1]
lab1.setText("Account : "+b.accountno+", Current Balance : "+b.amount);
return; // setting text to the label
}
if(str.equals("Show Details")) // checking show details or not
{
b
=newBankAccount(Integer.parseInt(t[0].getText()),Integer.parseInt(t[1].ge
tText()));
but1.setVisible(true);
show.setVisible(true);// setting visibility for 2 buttons
l[2].setVisible(true);
l[3].setVisible(true);
t[2].setVisible(true);
15

t[3].setVisible(true);
but.setVisible(false);
l[0].setVisible(false);// setting visibility for 4 labels and 4 textboxes
l[1].setVisible(false);
t[0].setVisible(false);
t[1].setVisible(false);
lab1.setText("Account : "+b.accountno+", Current Balance : "+b.amount);
// set text to the label lab1
return;
}
if(str.equals("User Credentials")) // checking user credentials or not
{
b
=newBankAccount(Integer.parseInt(t[0].getText()),Integer.parseInt(t[1].ge
tText()));
but1.setVisible(true);
show.setVisible(true);// setting visibility for 2 buttons
l[2].setVisible(true);
l[3].setVisible(true);
t[2].setVisible(true);
t[3].setVisible(true);
but.setVisible(false);
l[0].setVisible(false);// setting visibility for 4 labels and 4 textboxes
l[1].setVisible(false);
t[0].setVisible(false);
t[1].setVisible(false);
lab1.setText("Account : "+b.accountno+", Current Balance : "+b.amount);
// set text to the label lab1
return; // returning result
}
if(str.equals("Loan Details")) // checking loan details or not
{
b
=newBankAccount(Integer.parseInt(t[0].getText()),Integer.parseInt(t[1].ge
tText()));
// object creation for the class Bank Account
but1.setVisible(true);// setting visibility for the button but1
show.setVisible(true);// setting visibility for the buttonshow
l[2].setVisible(true); // setting visibility for the label l[2]
l[3].setVisible(true); // setting visibility for the label l[3]
t[2].setVisible(true); // setting visibility for the text box t[2]
t[3].setVisible(true); // setting visibility for the text box t[3]
but.setVisible(false); // setting visibility for the button but
l[0].setVisible(false);// setting visibility for the label l[0]
16

l[1].setVisible(false); // setting visibility for the label l[1]
t[0].setVisible(false); // setting visibility for the text box t[0]
t[1].setVisible(false); // setting visibility for the text box t[1]
lab1.setText("Account : "+b.accountno+", Loan Amount : "+b.amount);
return;
}
else
{
la
b.setText(testAccount(Integer.parseInt(t[2].getText()),Integer.parseInt(t
[3].getText())));// set text to the label lab
lab1.setText("Account : "+b.accountno+", Current Balance : "+b.amount);
// set text to the label lab1
}
}
}
publicclassBankManagerextendsBankTeller//BankTeller is extended
Inheritance
{
public void reverse(intaccno)
{
//reversing functionality
}
publicstaticvoidmain(Stringarg[]) // Implementation starts here
{
BankTellerat=newBankTeller(); // Object Creation for Base Class
at.setTitle("Banking Software for NatioNarrow Building Society"); //
setting title
at.setSize(600,200); // setting size
at.setVisible(true); // making visible
}
}
classNewWindowAdapterextendsWindowAdapter
{
publicvoidwindowClosing(WindowEventwe) // Window Closing
{
System.exit(0);// exiting
}
}
classBankAccount
17

{
intaccountno;
intamount;
BankAccount(intnum,intamt) // Account Creation with initial amount
{
accountno=num; // initializing value to accountno
amount=amt; // initializing value to amount
}
publicvoiddeposit(intamt)// depositing function
{
amount=amount+amt; // adding
}
publicvoidwithdraw(intamt) throwsFundsInsufficientException
// withdrawalfunction
{
if(amt>amount) // checks for sufficient amount
thrownewFundsInsufficientException(amount,amt); // raising exception
else
amount=amount-amt; // withdrawal
}
public void transfer(int no, intano)
{
//transfers an amount from one account to another
}
public void showall(int no)
{
// shows all the transactions of particular account
}
public void show (int no, Date d, Date d1)
{
// shows the transactions from one date to another
}
}
classFundsInsufficientExceptionextendsException
{
intbalance;
intwithdraw_amount;
FundsInsufficientException(intbal,intw_amt) // User Defined Exception
Method
{
18

balance=bal; //
withdraw_amount=w_amt;
}
publicStringtoString()
{
return"Thedrawing amount ("+withdraw_amount+") is to be below than an
existing balance ("+balance+"). Withdrawal never beprocessed.";//
specifying withdrawal //never be processed
}
}
Output
19

20

5. Critical Discussion : Introduction
NationNarrow Reflection and Critical-Evaluation
It’s a Banking Software for NatioNarrow Building Society. Actually the Role Performed by
Software Architect in team of System Analysis Designer is considered. The Software Main Users
are
 Bank Teller and then on behalf Customers
 Bank Manager
The user Performing Operations are categorized as follows:
The Bank Teller or a customer can do an operation of following
o Amount Depositing
o Amount Withdrawals and
o Fund Transfer.
o Showing all the transactions
o Bank statement between dates
o Requesting a balance update
The Bank Manager can do an operation of following
o Same operation of Bank Tellers. Additionally
o Creating new user credentials (user logins and passwords) if hiring new
staff.
o Approving and granting of loans,
o Approving to open various new bank accounts
21

Scope of the Software
The software is designed to satisfy the basic needs of Bank Customers, Bank Teller and
Bank Manager. It is devised to perform general operation like account creation under
several categories, deposit, withdrawal, enquiry about an account, fund transferring,
adding new credentials and sanctioning of loans with the help of an user friendly
interfaces. This system will work to perform various operations of Bank Teller and behalf
of a customer and Bank Manager various operations. This software is developed by
considering the utilization of its functionalities in a real time scenario before developing a
code it is critically analyzed with the provided requirements then it is followed by
development of various UML diagram like use case modeling diagram, class modeling
diagram and sequence model ling diagram. Based on the developed model the code
development has been taken place. Hence, this system will support the end user in all the
ways(Sergievskiy, 2017).
6. Critical self-reflection on the work
Software Development Life Cycle (SDLC) of this software
Requirement Gathering
The first and foremost process in any of the software development is collecting necessary
requirements from the clients. In this software development the case study is critically analyzed
to gather the proper requirements to perform all the designing and coding part. When the
requirements are not analyzed properly, it is not possible to provide a clear and detailed solution
to the end users. Once the requirements are clear according to the scenario, and then the half of
the problem is well solved .It represents the key objectives of a problem to be solved. At last the
developed code must met the produced requirements of the clients. If it is met, it’s a quality
product
22

E.g. here the case study scenario is stated precisely, which paves the path for gathering
basic requirements of the software
Design
Based on the gathered requirements it is analyzedthoroughlytodesign who are all the
actors and what actions they are going to perform in a Use case logical diagram. As it is
developed in java language that supports object oriented programming. Hence, it is required to
design another logical diagram which is termed as class diagram. It just represents different
classes and its attributes and functions along with the relationship between different classes
existing in a program. In this context, it is also represented with sequence diagram which
specifies the sequence of objet reactions in a program execution. It depicts the scenario of howan
one instance of a class interacts with an anotherobject. This modeling helps to focus on logical
representation of a system in three levels i.e. use case level, class level and scenario level.
Use case modeling diagram is employed for actor and their use case operation depiction.
ClassModeling Diagram is employed for representing class relationships and their attributes
representation. SequentialModeling Diagram is employed for the depiction of sequential actions
happening in a system(Sergievskiy, 2017).
Development
Based on the designing part the coding is generated which implements most of the object
oriented concepts like classes, objects, abstraction, encapsulation, inheritance, static binding,
message passing. As this software is designed in an object oriented programming language
named java which supports the major key concept of object oriented programming concepts. The
software utilizes the code reusable functionality. Java supports various built in packages for easy
creation of code. It is developed with the help of an Integrated Development Environment (IDE)
namely Microsoft Visual Studio Code version 1.36. This tool is employed for this software
customization in a user friendly manner. There are so many IDEs available on an Internet which
are all freely downloadable. This software also uses Java Frames (JFrame) to support GUI
features in java and also supports user friendly interfaces
23

Software Testing
Software testing is the practice to appraise the features of the software to test whether
software met the user needs with zero defects. It is possible to test software both manually and
automatically. In cases, test case and report is generated. The test case and its report is
ascertained for the quality of a product release. The input parameter is given to test the outcome
of a proposed software application. This software is programmed in such a way that to suit the
needy of end users by eliminating all the bugs. There are various testing types existing to test
source code workings which includemanual, automated (CASE) tools, white (glass) box, and
black (dark) box, functional, non functional.
Software testing has various altitudes of testing. It includes Testing by an Unit, Testing
by an integration, Testing through a system and Testing by the customer acceptance level
Unit Testing
This unit testing is exercised by testing a code in a unit by unit level i.e. class by class the
code is tested to check the reachability of a code. In critical projects the source is dividedinto
multiple parts or unit and tested individually. Here, in this software this unit testing is performed
to test each class performance.
Integrated Testing
This integration testing is exercised by testing a code in combined fashion. i.e. the
splitted classes are joined together and tested to check the reachability and integrated working of
a code. This testing plays a crucial role in checking the complete software functionality as per
the requirements of specifiedsoftware. Here, the software is tested in an integrated way by
combining all the classes together and experimented the amalgamation of separate class unit are
functioning very well
System Testing
This system testing is exercised after the amalgamation of unit testing. Here, the complete
software is organized and it is tested to fulfill the completeness and defects free software. In the
24

software development it is performed before the stage of user acknowledging testing
(Acceptance) . The whole system is investigated for the correctness of software.
Acceptance Testing
The project is proposed as per the requirements of the customer needs. The user checks
with a valid input and output, if the output suits the given input, and then customer is satisfied
Deployment
Deployment is ensured once the software is complete and all the bugs are fixed. It
ensures the software implementation is going to happen lively in the client site location. It is
going to be a last stage of process in the development life cycle of software. It provides the
actual solution whether the developed software is a high quality one or not. To deploy the
software the entire pre requisite has to be made well in advance to overcome the system,
network, platform, hardware difficulties in the client spot which reduces the risk of non
functioning of a software difficulties on the client site.This stage is attained once all the stage of
software testing is over and comes with defects free software level. Once all the testing’s are
satisfied with maximum quality and minimum defects, it is finally deployed at the client location
in an operational hierarchy
Feedback
After deployment, the feedback is entertained from the clients. The client feedback suggests
the actual outcome of softwarewhether the software is successful or not and also to assure that
the proposed software met all the needs also it suggests the developer to improve the software
further. The positive feedback does not require any changes in the SDLC further, but in case of
negative feedback it is to be incorporated in the next version and modified suggested feedback
has to be introduced in the further release shortly which paves the path for successful completion
of software
25

Issues: Professional, legal, social, security and ethical issues in development and use of
software in an organisational context.
The various issues pertaining to professional, legal, social, security and security during the
development and employing the software in an organization includes the following areas
 Improper understanding of requirements and Poor designing of code is a big issue in
professional software design. Software design process becomes successful when the
requirements are clearly defined and understood. The professional designing principles
specifies the same
 Proper implementation with privacy factor is a legal issue in software design. The
software has to be implemented with all the security features enabling the safety criteria
 Non assuring the quality software is a social issue in the development of software. The
quality focus of software should not be withdrawn at any cost. It reflects the efficiency of
the software performance
 Software with bugs, Inadequate Testing and Debugging,non safety features are security
related issues in the software development. The complete software development should
ensure the error free code with sufficient types and levels of testing process and
correcting errors in case of existence of error in a codingpart(R S Madanayake1, 2017)
 Improper reporting and investigation, improper usage and overconfidence in using
software is an ethical issues pertaining to software development. The Software
Development phase is to be reported promptly to the lead at proper time interval and
investigations has to be made in an utilization of the software principles
7. Conclusion
It is concluded that the designed software will meet the basic requirements of the customers,
bank tellers and bank managers in all the ways. It is also proposed by considering the highest
quality aspects with zero defects in a customer friendly way. This software is developed based on
the constructed models of use case diagram, class diagram and sequence diagram which are
specified earlier in the practical solution prototype. This software has undergone various testing
principles like Absence of error- fallacy, pesticide paradox, etc., also several types and levels of
26

testing are performed which affixes glass box, dark box testing, functional and non functional
testing and different hierarchy of testing from unit level to user acceptance level. From all the
levels of testing, it is apparently stated that the software is free from all forms of error
References
Baysal, O. K. (2016). Investigating technical and non-technical factors influencing modern code review.
Empircal Software Engineering , 932-959.
Felipe P. Vista IV 1, K. T. (2013). System Design, Development & Deployment Using Rapid By-Customer
Demand With Business Principles Approach. International Journal of Advanced Computer
Science and Application, 76-84.
Nunes, E. W. (2018). Investigating the effectiveness of peer code review in distributed software
development based on objective and subjective data. Journal of Software Engineering Research
and Development .
Pathak, M. S. (2017). Acceptance Testing Technique: A Survey along with Its Operating Frameworks .
International Journal on Research and Innovation Trends in Computing and Communications ,
772-775.
R S Madanayake1, G. K. (2017). Transforming Simplified Requirement in to a UML Use Case Diagram.
International Journal of Computer Science and Software Engineering , 61-70.
Saleh, O. S. (2015). Designing and Implementing of ATM System Using Object Oriented Approach.
International journal of Scientific & Engineering Research.
Sergievskiy, M. (2017). Description Logic Application for UML Class Diagrams Optimization. International
Journal of Advanced Computer Science and Applications, 5-10.
27