PART A – Micro-Project Proposal

Cafe Management System

1.0 Brief Introduction: -

Coffee Shop System is a simple application using graphical components in the Swing toolkit in Java. The
feature of this simple application includes calculating total bill with gross and VAT amount of a customer.
Here you can select an item from the list, the system displays its short description with size amount. The
user has to enter a total quantity, select the item size. After this, the system displays the total amount.

Besides, there are additional buttons for VAT amounts and senior citizen. This whole system is built using
Java programming language with the help of NetBeans IDE.

Design of this project is very simple so that the user won’t find any difficulties while working on it. To run
this project, you must have installed NetBeans IDE on your PC. Coffee Shop System in Java with source
code is free to download, Use for educational purposes only! For the project demo, have a look at the image
below.

2.0 Aim of the Micro-Project: -

The **aim of a Cafe Management System (CMS) project** in Advanced Java is to develop a reliable,
efficient, and user-friendly application that automates the core operations of a rest Cafe. The project
seeks to streamline processes, reduce human errors, and enhance the overall dining experience for both
customers and staff.

1. Automation of Cafe Management: To design and develop a software system that simplifies and
automates the management of a café, including order processing, bill calculation, and receipt
generation.

2. Interactive User Interface: To implement a user-friendly graphical interface using Java Swing,
making it intuitive and accessible for both employees and customers.

3. Error-Free Billing System: To ensure accurate and efficient calculation of bills, including taxes and
discounts, with minimal errors.

4. Enhanced Learning Outcomes: To provide hands-on experience in developing a Java-based

application using Object-Oriented Programming and Swing.

5. Cost and Item Tracking: To facilitate seamless management of items, including displaying their
costs and sizes, while calculating total costs for customers.

6. Educational Value: To demonstrate the practical implementation of Java programming concepts and
tools, including Swing components and event handling.

Page | 1
 7. Platform Independence: To create a lightweight application that is platform-independent and can
run on any system with a compatible Java runtime environment.

8. Scalability and Maintainability: To design the system with simplicity for easy future enhancements
or integration with other modules.

Overall, the CMS aims to improve cafe efficiency, minimize human errors, enhance the customer
experience, and provide management with the necessary tools for effective decision-making

3.0 Intended Course Outcomes: -

1. Application of Java Programming: Demonstrate the ability to design and implement a software
application using Java programming principles, focusing on practical problem-solving skills.

2. Mastery of Java Swing: Gain proficiency in creating graphical user interfaces (GUI) with Java
Swing, including the use of components like JButton, JTextField, and JTextArea.

3. Object-Oriented Programming (OOP): Apply advanced OOP concepts such as inheritance,

encapsulation, and polymorphism in the development of a real-world software solution.

4. Error Handling and Debugging: Learn techniques to identify, debug, and resolve errors in a
Java-based project effectively.

5. Software Development Lifecycle: Understand and execute all stages of the software
development lifecycle, including planning, implementation, testing, and deployment.

6. User-Centric Design: Develop skills to create user-friendly applications that prioritize ease of use
and functionality.

7. Integration of Taxation and Billing: Acquire the ability to incorporate financial logic, such as
calculating total costs, taxes, and discounts, into a functional application.

8. Hands-On Experience with IDEs: Utilize Integrated Development Environments (IDEs) like
NetBeans to enhance productivity and streamline the development process.

9. Practical Knowledge Application: Apply theoretical knowledge in a real-world scenario, bridging

the gap between academic concepts and industry practices.

10. Team Collaboration: Develop teamwork and project collaboration skills by working effectively in
a group to complete the project within a specified timeline.

Page | 2
4.0 Literature Review: -

Swing
It is a part of Java’s JFC (Java Foundation Classes) used for building graphical user interfaces
(GUIs). In your program, Swing is used to create the interface that interacts with users for various
functionalities like viewing the menu, adding menu items, and placing orders. The components and layouts
used in the program illustrate the versatility of Swing:
• JFrame: The JFrame is the top-level window that acts as the main frame of the application.
• JPanel: Panels are containers to organize components within a layout.
• JButton: Buttons like viewMenuButton, addMenuItemButton, and placeOrderButton are added to the
interface, allowing users to perform actions.
• JOptionPane: This is used for simple dialog boxes that allow users to interact with the system, such as
confirming actions or entering data.
• JComboBox: A dropdown is used for selecting menu items while placing an order.

The Swing framework allows you to build rich, interactive applications without relying on web browsers,
making it ideal for desktop systems like your restaurant management system.

JDBC
To fully implement a Cafe Management System, database integration is essential for
persisting data like menu items and orders. This is where JDBC (Java Database Connectivity) comes
in. JDBC allows Java applications to connect to and interact with a database (like MySQL,
PostgreSQL, etc.). With JDBC, you can store and retrieve information about menu items, orders, and
billing in a persistent and structured way.

How JDBC Can Be Integrated

In your current program, the data is stored in memory using ArrayList for menu items and orders, butthis
data will be lost when the application closes. By integrating JDBC, you can save and retrieve thisdata from
a relational database.

Page | 3
5.0 Proposed Methodology: -

In order to create any application/program following steps are followed.

• Problem Identification
• Requirement Analysis
• System Design
• Implementation
• Testing
• Documentation
• Deployment and Demonstration
• Evaluation and Feedback

We will follow the same above steps to create the micro project.

6.0 Resources Required: -

Sr. Name of Resource/material Specifications Qty Remarks

No.
1 PC Core i3, RAM 4GB 1

2 Operating System Windows 10/11 1

3 Software JDK 20, VS Code/Eclipse 1

Page | 4
7.0 Action Plan: -

Sr. Details of activity Planned Planned Name of

No. Start date Finish date Responsible Team
Members
1 Analysis 03/09 /2024 08/09/2024

2 Study Swing, JDBC 09/09/2024 13/09/2024

Design the Restaurant Management system
3 14/09/2024 17/09/2024
GUI
4 Write algorithm and draw program flowchart 18/09/2024 27/09/2024
Mohammad Yusuf
5 Coding and testing 02/10/2024 07/10/2024 Siddique

6 Coding and testing 09/10/2024 10/10/2024

7 Coding and testing 11/10/2024 13/10/2024

8 Coding and testing 15/10/2024 18/10/2024

9 Report writing 20/10/2024 22/10/2024

10 Demo and Submission 23/10/2024 24/10/2024

Submitted by:
1) Mohammad Yusuf Siddique

Page | 5
 PART B – Micro-Project Proposal

sCafe Management System

Acknowledgement

I would like to express my sincere gratitude to everyone who supported me throughout the
development of this Cafe Management System.
First and foremost, I am deeply grateful to Prof. Afzal Ahmad for their invaluable guidance,
encouragement, and insight, which provided me with the clarity and direction necessary for
completing this project.
I would also like to thank Jamia Polytechnic for providing the resources and tools essential for this
system's development. A special thanks goes to my colleagues and team members for their
collaborative efforts, constructive feedback, and constant support throughout this journey.
Finally, I am profoundly thankful to my family and friends for their unwavering support and
understanding during the entire process, which motivated me to put forth my best effort in
completing this project.

Thank you all for making this endeavor successful

Page | 6
 CONTENTS

1 Rationale ..................................................................................................... 8

2 Course Outcomes Addressed ................................................................. 8

3 Literature Review .............................................................................. 8-12

4 Actual Methodology followed ........................................................... 12

5 Actual Resources Required ......................................................................13

6 Output of Miro-Project .....................................................................14-19

7 Skills Developed/Learning out of this Micro-Project ............................ 19

8 Applications of this Micro-project .................................................... 20

9 Area of Future Improvement .......................................................... 20

Page | 7
1.0 Rational
The Cafe Management System project emerges from the pressing need for a solution that align with the
contemporary dining landscape. In a world where diners increasingly seek personalized and seamless
experiences, and where restaurant owners aim to boost their operational efficiency, technological solutions like
this system are essential. The restaurant industry is no longer limited to culinary delights alone; it is a dynamic
and competitive arena where the integration of technology is a requisite. The rationale behindthis project is
to facilitate the convergence of technology and culinary artistry, making dining out not just a source of
nourishment but a memorable experience.
The Cafe Management System contributes significantly to the growing body of knowledge on the practical
application of technology in the restaurant industry. By providing a user-friendly platform forcustomers to
explore menus, place orders with ease, and make payments, it enhances their diningexperience.
Moreover, it empowers restaurant owners and managers by simplifying menu management, order processing,
and billing. This project is a testament to the adaptability and innovation of the restaurant industry, proving
that technology can be harnessed to meet the needs of a tech-savvy clientele. Itunderscores the
industry's ability to evolve and remain competitive in a fast-paced, data-driven world,making it a
compelling case study in the modern restaurant management landscape.

2.0 Course Outcomes Addressed

1. Create an interactive webpage using program flow control structure.
2. Create event-based web forms using JavaScript.
3. Develop a fully functional web-application using HTML and JavaScript.

3.0 Literature Review

Swing
It is a part of Java’s JFC (Java Foundation Classes) used for building graphical user interfaces
(GUIs). In your program, Swing is used to create the interface that interacts with users for various
functionalities like viewing the menu, adding menu items, and placing orders. The components and layoutsused
in the program illustrate the versatility of Swing:
• JFrame: The JFrame is the top-level window that acts as the main frame of the application.
• JPanel: Panels are containers to organize components within a layout.
• JButton: Buttons like viewMenuButton, addMenuItemButton, and placeOrderButton are added to the
interface, allowing users to perform actions.
• JOptionPane: This is used for simple dialog boxes that allow users to interact with the system, such as
confirming actions or entering data.
• JComboBox: A dropdown is used for selecting menu items while placing an order.

Page | 8
The Swing framework allows you to build rich, interactive applications without relying on web browsers,
making it ideal for desktop systems like your restaurant management system.

JDBC
To fully implement a Restaurant Management System, database integration is essential for
persisting data like menu items and orders. This is where JDBC (Java Database Connectivity) comesin.
JDBC allows Java applications to connect to and interact with a database (like MySQL, PostgreSQL, etc.). With
JDBC, you can store and retrieve information about menu items, orders, and billing in a persistent and
structured way.

How JDBC Can Be Integrated

In your current program, the data is stored in memory using ArrayList for menu items and orders, but this data
will be lost when the application closes. By integrating JDBC, you can save and retrieve this datafrom a
relational database.

The Delegation Event Model

The modern approach to handling events is based on the delegation event model, which defines
standard and consistent mechanisms to generate and process events. Its concept is quite simple: a source
generates an event and sends it to one or more listeners. In this scheme, the listener
simply waits until it receives an event. Once an event is received, the listener processes the eventand
then returns. The advantage of this design is that the application logic that processes events is
cleanly separated from the user interface logic that generates those events. A user interface element
is able to “delegate” the processing of an event to a separate piece of code.
In the delegation event model, listeners must register with a source in order to receive an
event notification. This provides an important benefit: notifications are sent only to listenersthat
want to receive them. This is a more efficient way to handle events than the design used
by the old Java 1.0 approach. Previously, an event was propagated up the containment hierarchy
until it was handled by a component. This required components to receive events that they did not
process, and it wasted valuable time. The delegation event model eliminates this overhead

Event Sources
A source is an object that generates an event. This occurs when the internal state of that object
changes in some way. Sources may generate more than one type of event.
A source must register listeners in order for the listeners to receive notifications about a
specific type of event. Each type of event has its own registration method. Here is the
general form:

Page | 9
public void addTypeListener(TypeListener el)
Here, Type is the name of the event, and el is a reference to the event listener. For example, the
method that registers a keyboard event listener is called addKeyListener( ). The method that
registers a mouse motion listener is called addMouseMotionListener( ). When an event occurs, all
registered listeners are notified and receive a copy of the event object. This is knownas multicasting
the event. In all cases, notifications are sent only to listeners that register to receive them.

Event Listeners
A listener is an object that is notified when an event occurs. It has two major requirements.First, it
must have been registered with one or more sources to receive notifications about

specific types of events. Second, it must implement methods to receive and process these
notifications.
The methods that receive and process events are defined in a set of interfaces found in
java.awt.event.

Classes and Interfaces used:

Class JFrame
JFrame is an extended version of java.awt.Frame that adds support for the JFC/Swing component
architecture.

The ActionEvent Class

An ActionEvent is generated when a button is pressed, a list item is double-clicked, or a
menu item is selected. The ActionEvent class defines four integer constants that can be
used to identify any modifiers associated with an action event: ALT_MASK, CTRL_MASK,
META_MASK, and SHIFT_MASK. In addition, there is an integer constant, ACTION_
PERFORMED, which can be used to identify action events.
You can obtain the command name for the invoking ActionEvent object by using thegetActionCommand( )
method, shown here:
String getActionCommand( )
For example, when a button is pressed, an action event is generated that has a commandname
equal to the label on that button.

Page | 10
The getModifiers( ) method returns a value that indicates which modifier keys (ALT, CTRL,
META, and/or SHIFT) were pressed when the event was generated. Its form is shown here:int
getModifiers( )
The method getWhen( ) returns the time at which the event took place. This is called the
event’s timestamp. The getWhen( ) method is shown here:
long getWhen( )

The ActionListener Interface

This interface defines the actionPerformed( ) method that is invoked when an action eventoccurs.
Its general form is shown here:
void actionPerformed(ActionEvent ae)

JButton
The JButton class provides the functionality of a push button. You have already seen a simple
form of it in the preceding chapter. JButton allows an icon, a string, or both to beassociated
with the push button. Three of its constructors are shown here:
JButton(Icon icon)
JButton(String str)
JButton(String str, Icon icon)
Here, str and icon are the string and icon used for the button.
When the button is pressed, an ActionEvent is generated. Using the ActionEvent object
passed to the actionPerformed( ) method of the registered ActionListener, you can obtainthe
action command string associated with the button. By default, this is the string displayedinside
the button.

JTextField
JTextField is the simplest Swing text component. It is also probably its most widely used text
component. JTextField allows you to edit one line of text. It is derived from JTextComponent,
which provides the basic functionality common to Swing text components. JTextField uses the
Document interface for its model.
Three of JTextField’s constructors are shown here:
JTextField(int cols)
JTextField(String str, int cols)
JTextField(String str)
Here, str is the string to be initially presented, and cols is the number of columns in the text

Page | 11
 field. If no string is specified, the text field is initially empty. If the number of columns is not
specified, the text field is sized to fit the specified string.
JTextField generates events in response to user interaction. For example, an ActionEvent
is fired when the user presses ENTER. A CaretEvent is fired each time the caret (i.e., the
cursor) changes position. (CaretEvent is packaged in javax.swing.event.) Other events are
also possible. In many cases, your program will not need to handle these events. Instead,
you will simply obtain the string currently in the text field when it is needed. To obtain the
text currently in the text field, call getText( ).

Reference:

Books: -
1. Java the Complete Reference, ninth edition by Herbert Schild, Publisher: McGraw Hills
2. Head First EJB 3.0 by Kathy Sierra, Bert Bates, Publisher: O'Reilly Media
3. Head First Servlets and JSP by Bryan Basham, Kathy Sierra & Bert Bates, Publisher: O'Reilly
Media

Website: -
1. http://www.programmingearth.com
2. http://www.geeksforgeeks.com

4.0 Actual Methodology Followed

1. Plan: Define requirements, determine use cases.

2. Design: Create the system architecture, GUI, and event model.
3. Develop: Implement GUI components, core logic, event delegation, and data management.
4. Test: Perform unit testing, integration testing, and user acceptance testing.
5. Deploy: Package the system for delivery, install it, and configure databases (if applicable).
6. Maintain: Continuously monitor, update, and fix bugs as needed.

This methodology ensures the development of a reliable, user-friendly cafe management systemthat can
manage the core functions of a cafe effectively.

12 | P a g e
 Algorithm:
1. Start
2. Initialize menuItems, orderItems, and total Bill
3. Create a GUI window with menu, order, and control button’s
4. Add action listeners to buttons for viewing the menu, adding items, and placing order.
5. In the viewMenu() method:
6. Display the menu if not empty
7. Show a message if the menu is empty
8. In the addMenuItem() method:
9. Prompt the user to enter a menu item name and price
10. Add the new item to the menuItems list
11. Show a success message7. In the placeOrder() method:
12. Allow the user to select a menu item and quantity.
13. Calculate the order total
14. Add the order to the orderItems list
15. Update the total Bill
16. Display a success message
17. Determine the MenuItem and OrderItem classes

5.0 Actual Resources Used

Sr. No. Name of Resource/material Specifications Qty Remarks

1 PC Core i3, RAM 4GB 1

2 Operating System Windows 10 1
3 Software Turbo C 1

13 | P a g e
 6.0 Outputs of the Micro-Project
Coding:

package cafe.management;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class CafeManagementSystem extends JFrame {

// Declare Components
private JPanel panelLogin, panelMenu, panelReceipt;
private JTextField txtUsername, txtLatte, txtEspresso, txtCappuccino, txtTotalDrinks, txtTax, txtTotal;
private JPasswordField txtPassword;
private JTextArea txtReceipt;
private JButton btnLogin, btnLogout, btnCalculate, btnGenerateReceipt, btnClear, btnExit;

// Pricing Constants
private final double LATTE_PRICE = 3.50;
private final double ESPRESSO_PRICE = 4.00;
private final double CAPPUCCINO_PRICE = 3.75;
private final double TAX_RATE = 0.10;

// Constructor
public CafeManagementSystem() {
setTitle("Cafe Management System");
setSize(800, 600);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new CardLayout());

// Initialize Components
initializeLoginPanel();
initializeMenuPanel();
initializeReceiptPanel();

// Add Panels to CardLayout

add(panelLogin, "Login");
add(panelMenu, "Menu");
add(panelReceipt, "Receipt");

showPanel("Login");
}

private void initializeLoginPanel() {

panelLogin = new JPanel(new GridLayout(3, 2, 10, 10));
panelLogin.setBorder(BorderFactory.createTitledBorder("Login"));

JLabel lblUsername = new JLabel("Username:");

txtUsername = new JTextField();

14 | P a g e
JLabel lblPassword = new JLabel("Password:");
txtPassword = new JPasswordField();

btnLogin = new JButton("Login");

btnLogin.addActionListener(e -> {
String username = txtUsername.getText();
String password = new String(txtPassword.getPassword());

if (username.equals("admin") && password.equals("password")) {

showPanel("Menu");
} else {
JOptionPane.showMessageDialog(this, "Invalid credentials!", "Error", JOptionPane.ERROR_MESSAGE);
}
});

panelLogin.add(lblUsername);
panelLogin.add(txtUsername);
panelLogin.add(lblPassword);
panelLogin.add(txtPassword);
panelLogin.add(new JLabel());
panelLogin.add(btnLogin);
}

private void initializeMenuPanel() {

panelMenu = new JPanel(new GridLayout(5, 2, 10, 10));
panelMenu.setBorder(BorderFactory.createTitledBorder("Cafe Menu"));

JLabel lblLatte = new JLabel("Latte:");

txtLatte = new JTextField("0");

JLabel lblEspresso = new JLabel("Espresso:");

txtEspresso = new JTextField("0");

JLabel lblCappuccino = new JLabel("Cappuccino:");

txtCappuccino = new JTextField("0");

JLabel lblTotalDrinks = new JLabel("Total Drinks:");

txtTotalDrinks = new JTextField();
txtTotalDrinks.setEditable(false);

btnCalculate = new JButton("Calculate Total");

btnCalculate.addActionListener(e -> calculateTotal());

btnGenerateReceipt = new JButton("Generate Receipt");

btnGenerateReceipt.addActionListener(e -> showPanel("Receipt"));

btnClear = new JButton("Clear");

btnClear.addActionListener(e -> clearFields());

btnLogout = new JButton("Logout");

btnLogout.addActionListener(e -> showPanel("Login"));

panelMenu.add(lblLatte);
panelMenu.add(txtLatte);
panelMenu.add(lblEspresso);
panelMenu.add(txtEspresso);

15 | P a g e
panelMenu.add(lblCappuccino);
panelMenu.add(txtCappuccino);
panelMenu.add(lblTotalDrinks);
panelMenu.add(txtTotalDrinks);
panelMenu.add(btnCalculate);
panelMenu.add(btnGenerateReceipt);
panelMenu.add(btnClear);
panelMenu.add(btnLogout);
}

private void initializeReceiptPanel() {

panelReceipt = new JPanel(new BorderLayout());
panelReceipt.setBorder(BorderFactory.createTitledBorder("Receipt"));

txtReceipt = new JTextArea();

txtReceipt.setEditable(false);

btnExit = new JButton("Exit");

btnExit.addActionListener(e -> System.exit(0));

panelReceipt.add(new JScrollPane(txtReceipt), BorderLayout.CENTER);

panelReceipt.add(btnExit, BorderLayout.SOUTH);
}

private void calculateTotal() {

int latteCount = Integer.parseInt(txtLatte.getText());
int espressoCount = Integer.parseInt(txtEspresso.getText());
int cappuccinoCount = Integer.parseInt(txtCappuccino.getText());

double drinksCost = (latteCount * LATTE_PRICE) + (espressoCount * ESPRESSO_PRICE) +

(cappuccinoCount * CAPPUCCINO_PRICE);
double tax = drinksCost * TAX_RATE;
double total = drinksCost + tax;

txtTotalDrinks.setText(String.format("$%.2f", drinksCost));
txtTax.setText(String.format("$%.2f", tax));
txtTotal.setText(String.format("$%.2f", total));
}

private void clearFields() {

txtLatte.setText("0");
txtEspresso.setText("0");
txtCappuccino.setText("0");
txtTotalDrinks.setText("");
}

private void generateReceipt() {

int latteCount = Integer.parseInt(txtLatte.getText());
int espressoCount = Integer.parseInt(txtEspresso.getText());
int cappuccinoCount = Integer.parseInt(txtCappuccino.getText());

double drinksCost = (latteCount * LATTE_PRICE) + (espressoCount * ESPRESSO_PRICE) +

(cappuccinoCount * CAPPUCCINO_PRICE);
double tax = drinksCost * TAX_RATE;
double total = drinksCost + tax;

16 | P a g e
Calendar cal = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

txtReceipt.setText("Cafe Management System\n");

txtReceipt.append("======================\n");
txtReceipt.append("Latte: " + latteCount + " x $" + LATTE_PRICE + "\n");
txtReceipt.append("Espresso: " + espressoCount + " x $" + ESPRESSO_PRICE + "\n");
txtReceipt.append("Cappuccino: " + cappuccinoCount + " x $" + CAPPUCCINO_PRICE + "\n");
txtReceipt.append("----------------------\n");
txtReceipt.append("Subtotal: $" + drinksCost + "\n");
txtReceipt.append("Tax: $" + tax + "\n");
txtReceipt.append("Total: $" + total + "\n");
txtReceipt.append("----------------------\n");
txtReceipt.append("Date/Time: " + sdf.format(cal.getTime()) + "\n");
}

private void showPanel(String panelName) {

CardLayout cl = (CardLayout) getContentPane().getLayout();
cl.show(getContentPane(), panelName);
}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> new CafeManagementSystem().setVisible(true));
}
}

Output screen snapshot:

17 | P a g e
18 | P a g e
7.0 Skill Developed / learning out of this Micro-Project

Through the micro-project, the following things are learnt and skills are developed by the group

1. Developing the project in Advanced Java and utilizing the Swing framework enhances proficiency in
Java programming.
2. To know the Importance of this project.
3. The structure and requirement of Proposal and Report understood.
4. The necessity of group work is well understood.
5. What is the role of Group Leader and members? It is well understood.

19 | P a g e
8.0 Applications of this Micro-Project: -

A Restaurant Management System enhances order handling, billing, inventory, staff, reservations,
analytics, and integrates online ordering and loyalty programs.

9.0 Area of Future Improvement: -

Future Improvement Areas for the Cafe Management System:

1. AI-powered dish recommendations.

2. Advanced data analytics.

3. Improved user interface.

4. Mobile app integration.

5. Multilingual support.

6. Sustainability tracking.

7. Customizable reporting.

8. Enhanced CRM features.

20 | P a g e