Building a Java Vehicle Rental System with GUI : Step-by-Step Guide

Creating Java Vehicle Rental System

Explore our comprehensive guide on building a Java vehicle rental management program with a GUI. Whether you're a beginner or an experienced programmer, this guide offers valuable insights into Java GUI development, providing essential help with your Java assignment. Learn to create interactive vehicle rental systems step by step, and gain the skills to design and develop user-friendly software applications for various real-world scenarios. This project equips you with the knowledge needed to customize and extend interactive systems, making it a valuable asset for your programming journey.

Block 1: `Main` Class

```java
public class Main {
public static void main(String[] args) {
WestminsterSkinConsultationManager manager = new WestminsterSkinConsultationManager();
manager.run();
}
}
```

This block contains the main class that serves as the entry point of the program. It creates an instance of `WestminsterSkinConsultationManager` and runs its `run` method. This is the starting point of the program.

Block 2: Import Statements

```java
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
```

These import statements bring in necessary classes and packages, including GUI components and utilities for working with dates and lists.

Block 3: `MainGUI` Class

```java
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class MainGUI extends JFrame {
private WestminsterSkinConsultationManager consultationManager; // an instance of WestminsterSkinConsultationManager
private List vehicles; // a list of available vehicles
private JTable vehicleTable; // a table to display the available vehicles
private DefaultTableModel vehicleTableModel; // a table model for the vehicle table
public MainGUI(WestminsterSkinConsultationManager consultationManager) {
this.consultationManager = consultationManager;
this.vehicles = new ArrayList<>(consultationManager.getAvailableVehicles());
initGUI();
}
private void initGUI() {
setTitle("Westminster Skin Consultation Centre");
setSize(800, 600);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
// create the vehicle table and add it to a scroll pane
vehicleTableModel = new DefaultTableModel(new Object[]{"Type", "Plate", "Make", "Details"}, 0);
vehicleTable = new JTable(vehicleTableModel);
JScrollPane jScrollPane = new JScrollPane(vehicleTable);
add(jScrollPane, BorderLayout.CENTER);
// create a panel for the buttons and add the refresh and book buttons
JPanel buttonsPanel = new JPanel(new FlowLayout());
JButton refreshButton = new JButton("Refresh");
refreshButton.addActionListener(new RefreshButtonActionListener());
buttonsPanel.add(refreshButton);
JButton bookButton = new JButton("Book Slot");
bookButton.addActionListener(new BookButtonActionListener());
buttonsPanel.add(bookButton);
add(buttonsPanel, BorderLayout.SOUTH);
// load the vehicle table with data
loadVehicleTable();
}
// Rest of the MainGUI class code (omitted for brevity)
// ...
}
```

This block defines the `MainGUI` class, which extends `JFrame` to create the graphical user interface for managing vehicle rentals. The class includes instance variables, a constructor, and methods for initializing the GUI and managing vehicle data.

Block 4: `initGUI` Method

```java
private void initGUI() {
setTitle("Westminster Skin Consultation Centre");
setSize(800, 600);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
// create the vehicle table and add it to a scroll pane
vehicleTableModel = new DefaultTableModel(new Object[]{"Type", "Plate", "Make", "Details"}, 0);
vehicleTable = new JTable(vehicleTableModel);
JScrollPane jScrollPane = new JScrollPane(vehicleTable);
add(jScrollPane, BorderLayout.CENTER);
// create a panel for the buttons and add the refresh and book buttons
JPanel buttonsPanel = new JPanel(new FlowLayout());
JButton refreshButton = new JButton("Refresh");
refreshButton.addActionListener(new RefreshButtonActionListener());
buttonsPanel.add(refreshButton);
JButton bookButton = new JButton("Book Slot");
bookButton.addActionListener(new BookButtonActionListener());
buttonsPanel.add(bookButton);
add(buttonsPanel, BorderLayout.SOUTH);
// load the vehicle table with data
loadVehicleTable();
}
```

This method initializes the GUI by setting the frame's properties, creating a table to display vehicle information, adding buttons for refreshing and booking slots, and loading data into the table.

Block 5: `loadVehicleTable` Method

```java
private void loadVehicleTable() {
// Clear the existing rows from the table model
vehicleTableModel.setRowCount(0);
// Sort the list of vehicles by license plate
vehicles.sort((v1, v2) -> v1.getPlate().compareToIgnoreCase(v2.getPlate()));
// Add each vehicle to the table model
for (Vehicle vehicle : vehicles) {
if (vehicle instanceof Car) {
Car car = (Car) vehicle;
vehicleTableModel.addRow(new Object[]{"Car", car.getPlate(), car.getMake(),
"Engine: " + car.getEngineType() + ", Doors: " + car.getNumOfDoors()});
} else if (vehicle instanceof Motorbike) {
Motorbike motorbike = (Motorbike) vehicle;
vehicleTableModel.addRow(new Object[]{"Motorbike", motorbike.getPlate(), motorbike.getMake(),
"Seats: " + motorbike.getNumOfSeats() + ", Engine Size: " + motorbike.getEngineSize()});
}
}
}
```

This method is responsible for loading vehicle data into the table. It clears existing rows, sorts the list of vehicles, and adds each vehicle to the table model. It differentiates between cars and motorbikes when displaying vehicle details.

Block 6: `RefreshButtonActionListener` Class

```java
// Listener for the refresh button
private class RefreshButtonActionListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
// Update the list of vehicles and reload the table
vehicles = new ArrayList<>(consultationManager.getAvailableVehicles());
loadVehicleTable();
}
}
```

This inner class defines an action listener for the "Refresh" button. When the button is clicked, it updates the list of available vehicles and reloads the table.

Block 7: `BookButtonActionListener` Class

```java
// Listener for the book button
private class BookButtonActionListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
// Get the selected vehicle from the table and show a rental slot dialog
int selectedRow = vehicleTable.getSelectedRow();
if (selectedRow >= 0) {
Vehicle vehicle = vehicles.get(selectedRow);
RentalSlotDialog rentalSlotDialog = new RentalSlotDialog(vehicle);
rentalSlotDialog.setVisible(true);
} else {
JOptionPane.showMessageDialog(MainGUI.this, "Please select a vehicle to book a slot.");
}
}
}
```

This inner class defines an action listener for the "Book Slot" button. It allows users to select a vehicle from the table and open a dialog for booking a rental slot.

Block 8: `RentalSlotDialog` Class

```java
// Dialog for booking a rental slot
private class RentalSlotDialog extends JDialog {
private Vehicle vehicle;
private JTextField pickupDateField;
private JTextField dropoffDateField;
public RentalSlotDialog(Vehicle vehicle) {
this.vehicle = vehicle;
setTitle("Book a Slot: " + vehicle.getMake() + " " + vehicle.getPlate());
setSize(700, 500);
setLayout(new GridLayout(3, 2);
// Add fields for the pick-up and drop-off dates and times
add(new JLabel("Pick-up Date & Time (dd/MM/yyyy HH:mm):"));
pickupDateField = new JTextField();
add(pickupDateField);
add(new JLabel("Drop-off Date & Time (dd/MM/yyyy HH:mm):"));
dropoffDateField = new JTextField();
add(dropoffDateField);
// Add buttons for canceling or booking the rental slot
JButton cancelButton = new JButton("Cancel");
cancelButton.addActionListener(e -> dispose());
add(cancelButton);
JButton calculateButton = new JButton("Calculate & Book");
calculateButton.addActionListener(new CalculateButtonActionListener());
add(calculateButton);
}
// Listener for the calculate and book button
private class CalculateButtonActionListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
// Handle booking calculations and validations
// ...
}
}
}
```

This inner class represents a dialog for booking a rental slot. It includes fields for entering pickup and drop-off dates and times, along with buttons for canceling or booking the slot.

Block 9: `CalculateButtonActionListener` Class

```java
// Listener for the calculate and book button
private class CalculateButtonActionListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
try {
// Parse the pick-up and drop-off dates and times
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm");
Date pickupDate = dateFormat.parse(pickupDateField.getText());
Date dropoffDate = dateFormat.parse(dropoffDateField.getText());
// Check that the drop-off date is after the pick-up date
if (dropoffDate.before(pickupDate)) {
JOptionPane.showMessageDialog(RentalSlotDialog.this, "Drop-off date must be after pick-up date.");
return;
}
// Check if the vehicle can be booked for the given time slot
if (!vehicle.canBeBooked(pickupDate, dropoffDate)) {
JOptionPane.showMessageDialog(RentalSlotDialog.this, "This Vehicle cannot be booked in this slot. Please select some other timings.");
return;
}
// Calculate the cost of the rental slot
double hours = (dropoffDate.getTime() - pickupDate.getTime()) / 3600000.0;
double pricePerHour = vehicle instanceof Car ? 20 : 10;
double cost = hours * pricePerHour;
double discount = 0;
// Apply a discount based on the duration of the rental
if (hours > 72) {
discount = cost * 0.1;
} else if (hours > 48) {
discount = cost * 0.05;
}
double finalCost = cost - discount;
// Show a confirmation dialog with the cost, discount, and total
int result = JOptionPane.showConfirmDialog(
RentalSlotDialog.this,
String.format(
"Cost: £%.2f\nDiscount: £%.2f\nTotal: £%.2f\n\nConfirm booking?",
cost, discount, finalCost
),
"Booking Confirmation",
JOptionPane.YES_NO_OPTION
);
// If the user confirms the booking, set the rental slot for the vehicle and show a success message
if (result == JOptionPane.YES_OPTION) {
RentalSlot rentalSlot = new RentalSlot(pickupDate, dropoffDate);
vehicle.setRentalSlot(rentalSlot);
JOptionPane.showMessageDialog(
RentalSlotDialog.this,
"Booking successful. Thank you for using Westminster Skin Consultation Centre."
);
dispose();
}
} catch (ParseException ex) {
JOptionPane.showMessageDialog(
RentalSlotDialog.this,
"Invalid date format. Please use the format: dd/MM/yyyy HH:mm."
);
}
}
}
```

This inner class defines an action listener for the "Calculate & Book" button within the `RentalSlotDialog`. It handles the calculation of the cost for the rental slot, applies discounts, and confirms the booking.

Block 10: `main` Method in `MainGUI` Class

```java
public static void main(String[] args) {
WestminsterSkinConsultationManager consultationManager = new WestminsterSkinConsultationManager();
MainGUI mainGUI = new MainGUI(consultationManager);
mainGUI.setVisible(true);
}
```

This is a `main` method that creates an instance of `WestminsterSkinConsultationManager` and `MainGUI`, setting the GUI visible for user interaction.

Block 11: `Car` Class

```java
public class Car extends Vehicle {
private String engineType;
private int numOfDoors;
public Car(String plate, String make, String engineType, int numOfDoors) {
super(plate, make);
this.engineType = engineType;
this.numOfDoors = numOfDoors;
}
public String getEngineType() {
return engineType;
}
public void setEngineType(String engineType) {
this.engineType = engineType;
}
public int getNumOfDoors() {
return numOfDoors;
}
public void setNumOfDoors(int numOfDoors) {
this.numOfDoors = numOfDoors;
}
}
```

This block defines the `Car` class, which extends the `Vehicle` class. It includes properties like `engineType` and `numOfDoors`, along with getter and setter methods.

Block 12: `Motorbike` Class

```java
public class Motorbike extends Vehicle {
private int numOfSeats;
private int engineSize;
public Motorbike(String plate, String make, int numOfSeats, int engineSize) {
super(plate, make);
this.numOfSeats = numOfSeats;
this engineSize = engineSize;
}
public int getNumOfSeats() {
return numOfSeats;
}
public void setNumOfSeats(int numOfSeats) {
this.numOfSeats = numOfSeats;
}
public int getEngineSize() {
return engineSize;
}
public void setEngineSize(int engineSize) {
this.engineSize = engineSize;
}
}
```

This block defines the `Motorbike` class, which also extends the `Vehicle` class. It includes properties like `numOfSeats` and `engineSize`, along with getter and setter methods.

Block 13: `RentalManager` Interface

```java
import java.util.List;
interface RentalManager {
void addVehicle(Vehicle vehicle);
void removeVehicle(Vehicle vehicle);
List getAvailableVehicles();
}
```

This block defines the `RentalManager` interface, which includes methods for adding and removing vehicles and retrieving available vehicles.

Block 14: `RentalSlot` Class

```java
import java.util.Date;
public class RentalSlot {
private Date pickupDateTime;
private Date dropoffDateTime;
public RentalSlot(Date pickupDateTime, Date dropoffDateTime) {
this.pickupDateTime = pickupDateTime;
this.dropoffDateTime = dropoffDateTime;
}
public Date getPickupDateTime() {
return pickupDateTime;
}
public void setPickupDateTime(Date pickupDateTime) {
this.pickupDateTime = pickupDateTime;
}
public Date getDropoffDateTime() {
return dropoffDateTime;
}
public void setDropoffDateTime(Date dropoffDateTime) {
this.dropoffDateTime = dropoffDateTime;
}
}
```

This block defines the `RentalSlot` class, representing a rental slot with pickup and drop-off date-time properties.

Block 15: `Vehicle` Class

```java
import java.util.Date;
abstract class Vehicle {
private String plate;
private String make;
private RentalSlot rentalSlot;
public Vehicle(String plate, String make) {
this.plate = plate;
this.make = make;
this.rentalSlot = null;
}
public String getPlate() {
return plate;
}
public void setPlate(String plate) {
this.plate = plate;
}
public String getMake() {
return make;
}
public void setMake(String make) {
this.make = make;
}
public void setRentalSlot(RentalSlot slot){
this.rentalSlot = slot;
}
public RentalSlot getRentalSlot(){
return rentalSlot;
}
public boolean canBeBooked(Date pickupDate, Date dropoffDate) {
if (rentalSlot == null) {
return true;
}
Date currentPickupDate = rentalSlot.getPickupDateTime();
Date currentDropoffDate = rentalSlot.getDropoffDateTime();
// Check if the specified pickup date is after the current drop-off date
if (pickupDate.after(currentDropoffDate)) {
return true;
}
// Check if the specified drop-off date is before the current pickup date
if (dropoffDate.before(currentPickupDate)) {
return true;
}
// Otherwise, the vehicle is not available during the specified rental period
return false;
}
}
```

This block defines the abstract `Vehicle` class, which includes properties like `plate`, `make`, and `rentalSlot`, along with methods for checking if a vehicle can be booked.

Conclusion

This Java program for managing vehicle rentals with a GUI is a versatile and practical solution for businesses in the vehicle rental industry. It allows users to interact with a user-friendly interface, book rental slots, and calculates costs with discounts. You can adapt and enhance this program to meet specific business needs, making it a valuable tool for vehicle rental management. By implementing this project, you gain valuable experience in building interactive software applications, which can be extended and customized for various real-world applications. Whether you're managing a vehicle rental business or simply learning Java programming, this project equips you with the knowledge and skills needed to create sophisticated, user-friendly systems.

Developing a Java Vehicle Rental Management Program with GUI