ABSTRACT

The Simple Retail Billing System (RBS) is a console-

based application developed in Java aimed at simulating
the transaction and billing process in a small retail store.
The project is designed to manage product inventory,
calculate total bill amounts, and track daily sales. It
emphasizes key Java concepts such as Object-Oriented
Programming (OOP), with classes like Product and Bill,
and the strategic use of Collection Frameworks
(ArrayList) for dynamic list management. Crucially, the
system utilizes File Handling (Serialization or Text I/O) to
ensure product stock levels and transaction history
persist, making it a complete and practical
demonstration of Java development principles.
 Existing System Analysis

Small retail shops often rely on manual or basic

electronic methods for billing, which presents
several drawbacks:
* Manual Calculation: Using simple calculators for
tallying costs.
* Drawbacks: High probability of calculation
errors, slow transaction times, and no automated
way to apply discounts or calculate taxes
consistently.
* Lack of Inventory Integration: Billing is separate
from stock management.
* Drawbacks: The shop owner doesn't know the
current stock level automatically after a sale,
leading to poor inventory control and potential
stockouts.
* Non-existent Transaction History: No easy way
to review past sales or generate reports (e.g., daily
sales summaries).
The existing manual system is inefficient, error-
prone, and provides no insightful data for business
management.
 Proposed System

The Simple Retail Billing System (RBS) provides a

structured, automated solution to manage the sales
process:
* Platform: Console-based application using Java.
* Key Classes: Product, Bill, and the central Billing
Manager class.
 Key Features:
* Product Management: Add, update, and search for
products (Product ID, Name, Price, Stock Quantity).
* Billing Transaction: Create a new bill by adding
products one by one, automatically calculating subtotals,
grand total, and tax.
* Stock Update: Automatically decrease the stock
quantity of a product after it is added to a bill.
* Sales History: Store completed bills for later review.
* Data Persistence: Product inventory and bill records
are saved to files ([Link], [Link]) using
serialization.
* Benefits: High accuracy in billing, real-time inventory
updates, and the ability to generate transaction records
for auditing and analysis.
 Introduction

The Retail Billing System is an ideal project for a student

to apply transactional logic—where multiple data points
(price, quantity, stock) must be updated simultaneously
and correctly.
The project mandates the effective use of ArrayList to
store the dynamic list of available Product objects and
completed Bill objects. The core challenge lies in
implementing the Billing Transaction method, which
involves looping to add items, performing checks (Is
there enough stock?), and updating the product list after
the bill is finalized. Mastery of exception handling is
critical here to prevent crashes due to invalid entries
(e.g., entering letters for product price or quantity). The
overall structure, driven by a clear main menu, provides
a solid framework for understanding application flow and
modular development.
 Source Code
A. [Link]
import [Link];

public class Product implements Serializable {

private int productId;
private String name;
private double price;
private int stock; // Current quantity in inventory

// Constructor
public Product(int productId, String name, double
price, int stock) {
[Link] = productId;
[Link] = name;
[Link] = price;
[Link] = stock;
}

// Getters and Setters

public int getProductId() { return productId; }
public String getName() { return name; }
 public double getPrice() { return price; }
public int getStock() { return stock; }

public void updateStock(int quantityChange) {

// quantityChange can be positive (restock) or
negative (sale)
[Link] += quantityChange;
}

@Override
public String toString() {
return "ID: " + productId + ", Name: " + name +
" (Rs. " + price + "), Stock: " + stock;
}
}
B. [Link] (Main Class)
(The main class includes methods for loadData(),
saveData(), addProduct(), and the complex
createNewBill() method.)
import [Link].*;
import [Link].*;

public class BillingManager {

private static ArrayList<Product> products = new
ArrayList<>();
// private static ArrayList<Bill> bills = new
ArrayList<>(); // To store completed bills
private static Scanner scanner = new
Scanner([Link]);

public static void main(String[] args) {

// loadData() would run here

int choice = 0;
do {
[Link]("\n** RETAIL BILLING
SYSTEM **");
[Link]("1. Add New Product");
 [Link]("2. Display All Products
(Stock)");
[Link]("3. Create New Bill (Sale)");
[Link]("4. Exit and Save Data");
[Link]("Enter choice: ");

try {
choice = [Link]();
[Link]();

switch (choice) {
case 1:
// addProduct() implementation
break;
case 2:
displayProducts();
break;
case 3:
// createNewBill() implementation
break;
case 4:
// saveData() implementation
 [Link]("Inventory saved.
System shutting down...");
break;
default:
[Link]("Invalid option.");
}
} catch (InputMismatchException e) {
[Link]("Error: Invalid input format.
Please enter a number.");
[Link]();
choice = 0;
}
} while (choice != 4);
}

private static void displayProducts() {

if ([Link]()) {
[Link]("No products in inventory.");
return;
}
[Link]("\n--- Current Inventory ---");
for (Product p : products) {
 [Link](p);
}
}

// The createNewBill() method would involve a loop to

find products by ID,
// check stock ([Link]() >= quantity), and call
[Link](-quantity) if successful.
}
 Output
Scenario 1: Adding Products to Inventory
* RETAIL BILLING SYSTEM *
...
Enter choice: 1
Enter Product ID: 1001
Enter Product Name: Milk (1L)
Enter Price: 55.00
Enter Initial Stock Quantity: 50
Product added successfully!

* RETAIL BILLING SYSTEM *

...
Enter choice: 1
Enter Product ID: 1002
Enter Product Name: Bread (Sandwich)
Enter Price: 40.00
Enter Initial Stock Quantity: 30
Product added successfully!

Scenario 2: Creating a Bill (Simplified Transaction)

* RETAIL BILLING SYSTEM *
...
Enter choice: 3
--- STARTING NEW BILL ---
Enter Product ID to add (0 to Finish Bill): 1001
Enter Quantity: 2
Item added: Milk (1L) x 2. Current Subtotal: Rs. 110.00.
Stock updated (48 remaining).

Enter Product ID to add (0 to Finish Bill): 1002

Enter Quantity: 1
Item added: Bread (Sandwich) x 1. Current Subtotal: Rs.
150.00. Stock updated (29 remaining).

Enter Product ID to add (0 to Finish Bill): 0

* FINAL BILL *
Gross Total: Rs. 150.00
Tax (5%): Rs. 7.50
----------------------
Grand Total: Rs. 157.50
Bill completed.
Scenario 3: Checking Final Stock
* RETAIL BILLING SYSTEM *
...
Enter choice: 2

--- Current Inventory ---

ID: 1001, Name: Milk (1L) (Rs. 55.0), Stock: 48
ID: 1002, Name: Bread (Sandwich) (Rs. 40.0), Stock: 29
 Conclusion

The Simple Retail Billing System (RBS) serves as an

effective learning tool by integrating inventory and
financial calculations within a single transactional
process. The project successfully demonstrates the
ability to manage dynamic lists of objects, perform
complex stock updates, and implement robust File
Handling to maintain inventory data. This hands-on
experience in building a transaction-based system is
invaluable for a Class 12 student, providing a strong
foundation for tackling more advanced concepts like
database integration and concurrent processing in future
IT studies.